Jérémy DECOOL (@jdecool), Ingénieur Etudes et Développement à Lyon

Push once, publish everywhere: the multi-target Git remote

Tue, 14 Jul 2026 00:00:00 +0200

Github remains the go-to forge for hosting Git projects today. But as a French guy who lives in Europe, I don’t want to depend on only one foreign platform. So, to reduce that dependency, I decided to mirror all of my repositories (public and private) on Codeberg, a European, non-profit forge.

Usually, people think a Git remote is a simple association with a URL (one remote = one destination). In reality, a remote is two things: a URL for fetching data and another one for pushing data. Using the git remote -v command, it’s possible to visualize a repository configuration:

$ git remote -v
origin  https://github.com/jdecool/repo.git (fetch)
origin  https://github.com/jdecool/repo.git (push)

Git allows to configure multiple push URLs to a remote. It’s what I do to push repository changes to Github and the Codeberg mirror:

To declare the push URLs, use the git remote set-url command with the --add and --push options:

$ git remote set-url --add --push origin git@github.com:jdecool/repo.git
$ git remote set-url --add --push origin ssh://git@codeberg.org/jdecool/repo.git

It produces the following result:

$ git remote -v
origin  https://github.com/jdecool/repo.git (fetch)
origin  https://github.com/jdecool/repo.git (push)
origin  ssh://git@codeberg.org/jdecool/repo.git (push)

Now the origin remote still fetches data from Github, but it also pushes data on two destinations. The Git configuration is stored in the .git/config file:

[remote "origin"]
    url = git@github.com:jdecool/repo.git
    fetch = +refs/heads/*:refs/remotes/origin/*
    pushurl = git@github.com:jdecool/repo.git
    pushurl = ssh://git@codeberg.org/jdecool/repo.git

Now, when I push changes with git push origin main, Git will send commits to both Github and Codeberg. Both repository instances stay up to date.

But there are some important things to notice.

Fist, by default, Git uses the fetch URL for pushing as well. But after you add a first pushurl, the implicit fetch URL is no longer used, it will be replaced. So make sure to declare the original URL alongside the new one.

Secondly, this technique remains a one-way mirror. The fetch URL still contains only one URL. If some code is directly pushed to a secondly instance, those changes won’t be pulled back automatically. In a team context, prefer using the Git mirror feature from the forge server-side.

Profile your PHPUnit tests using OpenTelemetry

Mon, 01 Jun 2026 00:00:00 +0200

When your project grows, the codebase grows and your test suite too. The more the test you write, the longer the execution is. And then, the Allowed memory size exhausted error occurred in your CI. To solve this issue quickly, you bump PHP allocated memory. But it doesn’t fix the problem, and this cycle goes on for a while. Until you hit critical thresholds.

Fixing memory issues is really difficult, and there are not many tools to help. We need to retrieve information about our test executions. Monitoring a production application is a known good practice. So why this is not applied to our test code?

The OpenTelemetry emerged those years. It could be useful to use it in our context to produce traces and metrics about our test suite.

I’ve recently discovered the flow-php/phpunit-telemetry-bridge library. It brings observability to our PHPUnit tests using OpenTelemetry. The library consists of a PHPUnit extension that collects some data and sends them to any OTLP-compatible backend.

Start using it by installing the component using Composer:

composer require --dev flow-php/phpunit-telemetry-bridge

Then add the telemetry configuration into PHPUnit:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit>
    <!-- ... -->
    <extensions>
        <bootstrap class="Flow\Bridge\PHPUnit\Telemetry\TelemetryExtension">
            <parameter name="service_name" value="phpunit-opentelemetry"/>
            <parameter name="transport" value="curl"/>
            <parameter name="endpoint" value="http://localhost:4318"/>
            <parameter name="emit_traces" value="true"/>
            <parameter name="emit_metrics" value="true"/>
            <parameter name="emit_test_spans" value="true"/>
            <parameter name="emit_test_case_spans" value="true"/>
            <parameter name="curl_connect_timeout_ms" value="1000"/>
            <parameter name="curl_timeout_ms" value="2000"/>
        </bootstrap>
    </extensions>
</phpunit>

After that, every time your tests are run, the library will send the telemetry backend. Then you can create some dashboards to visualize the data:

Data contains execution details like duration, memory consumption, executed tests, etc.

When using observability in your stack, don’t forget that instrumenting every test can be expensive. Use it when you really need it.

Want to get more information? Check out the PHPUnit Telemetry bridge documentation.

Using PHP with Airflow

Mon, 18 May 2026 00:00:00 +0200

I’m currently working on a BI project where scripts are written in Python and orchestrated by Apache Airflow. Airflow was originally designed and built for the Python ecosystem. But as a PHP developer, I want to use Airflow to orchestrate PHP stuff.

Airflow tasks (called DAG for Directed Acyclic Graph) are executed through operators. One of them is the BashOperator which allows to run a command directly on an Airflow worker. So if PHP is installed on it, a script can be executed.

Let’s take this simple PHP script as an example:

<?php

echo "Hello from PHP script!\n";
echo "Execution time: " . date('Y-m-d H:i:s') . "\n";

To create a DAG, we need to write some Pyhton code (it’s the only moment where Python is needed):

from airflow import DAG
from airflow.providers.standard.operators.bash import BashOperator
from datetime import datetime

with DAG(
    dag_id="run_php_script",
    description="A DAG that runs a PHP script",
    schedule=None,
    start_date=datetime(2024, 1, 1),
    catchup=False,
    tags=["php"],
) as dag:

    run_php_script = BashOperator(
        task_id="run_php_script",
        bash_command="php /path/to/scripts/hello.php",
    )

The previous code triggers a PHP script into Airflow. Standard output and error are automatically captured in logs.

If you want to try it yourself, this repository has everything you need to spin up an Airflow environment ready to go.

Execute CTE queries using Doctrine ORM

Sat, 09 May 2026 00:00:00 +0200

There are a lot of developers who manipulate databases using an ORM and don’t know more SQL than the “classic” SELECT ... FROM ... WHERE ... queries. But databases have various unknown features that can avoid programing data processing. One of them is CTE (for Common Table Expressions).

This article describes how to use this feature with PHP Doctrine ORM.

First, let me explain what a CTE is. A Common Table Expression (CTE) is a named temporary result set that you define at the beginning of a SQL query using the WITH clause. It exists only for the duration of that query and can be referenced like a table within it.

To illustrate how it works, imagine a blog where articles can be stored and attached to one category. Categories are organized in a tree structure. Now, we want to retrieve a specific category with all its parents. The naïve PHP implementation can be something like:

// src/Repository/CategoryRepository.php
class CategoryRepository extends ServiceEntityRepository
{
    // ...

    /**
     * @return list<Category>
     */
    function getCatagoriesWithParents(int $categoryId): array
    {
        $category = $this->categoryRepository->find($categoryId);

        $categories = [
            $category,
        ];

        while ($parent = $category->getParent()) {
            $categories[] = $parent;
        }

        return $categories;
    }
}

With the previous version, Doctrine will execute one query per loop: it’s the common N+1 problem. To resolve this issue through an SQL query, we can’t use a basic query. We need a recursive CTE. This SQL query can look like:

WITH RECURSIVE cte_category AS (
    -- starting point
    SELECT id, label, parent_id, 0 AS depth
    FROM category
    WHERE id = :id

    UNION ALL

    -- recursivity
    SELECT c.id, c.label, c.parent_id, cp.depth + 1
    FROM category c
    INNER JOIN cte_category cp ON c.id = cp.parent_id
)
SELECT id, label, parent_id FROM cte_category
ORDER BY depth DESC

First, the previous query retrieves the :id category. Then, recursively, it retrieves all the parents. The depth column is used to order the final result.

The problem with this kind of SQL query is that Doctrine is not able to execute them natively. We can’t use the QueryBuilder or a DQL (Doctrine Query Language) query. We need to execute a native query and map the result on an object.

// src/Repository/CategoryRepository.php
class CategoryRepository extends ServiceEntityRepository
{
    // ...

    public function findAllWithParents(int $categoryId)
    {
        $rsm = new ResultSetMappingBuilder($this->getEntityManager());
        $rsm->addRootEntityFromClassMetadata(Category::class, 'c');

        $sql = <<<SQL
            WITH RECURSIVE with_categories AS (
                SELECT id, label, parent_id, 0 AS depth
                FROM category
                WHERE id = :id

                UNION ALL

                SELECT c.id, c.label, c.parent_id, cp.depth + 1
                FROM category c
                INNER JOIN with_categories cp ON c.id = cp.parent_id
            )
            SELECT id, label, parent_id FROM with_categories
            ORDER BY depth DESC
        SQL;

        return $this->getEntityManager()
            ->createNativeQuery($sql, $rsm)
            ->setParameter('id', $categoryId)
            ->getResult();
    }
}

In the previous code, the ResultSetMappingBuilder maps the query results to the Category entity object properties. The output will be a list of Category ordered by ancestors.

This kind of query allows a lot of things. For example, we can retrieve every post of a specific category, including the category parents:

WITH RECURSIVE category_path AS (
    SELECT id, label, parent_id
    FROM category
    WHERE id = :id

    UNION ALL

    SELECT c.id, c.label, c.parent_id
    FROM category c
    INNER JOIN category_path cp ON c.id = cp.parent_id
)
SELECT a.id, a.title, a.category_id
FROM article a
INNER JOIN category_path cp ON a.category_id = cp.id
ORDER BY a.published_date DESC

With only one query, every post is retrieved. Without a recursive CTE, multiple successive queries will be necessary. The drawback is it depends on the database engine and could not be available in some databases.

Moreover, using the ResultSetMappingBuilder requires all columns needed to hydrate the entity should be included in the SELECT. Otherwise, the entity will be partially hydrated without any explicit notice or error.

Learning a New Programming Language in the AI era

Sat, 02 May 2026 00:00:00 +0200

Every year, I try to learn a new programming language. Over the years, I’ve learned or (re)discovered languages like Ruby, Elixir, Rust, Go, Python or Typescript. This year, it will be C#. But in the AI era, where lesser and lesser code is humanly written, still it interesting ?

In my own opinion, the answer is: yes, it is. Even if the AI is everywhere, in our every day or professional life. I use it to explore and generate code to help me find solutions and to accelerate software implementation. But the more we use AI, the less our brain is used to manipulate basic concepts of our programming job.

So it’s necessary to be active and learning a new language is a way to review basics. I’ve always liked to write code, thinking about what I want to build and then be able to materialize it. It’s also a way to keep my judgment capacity to evaluate code quality.

Moreover, by learning a new programming language, I can discover new practices and principles than I used to work with my primary language. Each language has its own philosophy and it’s a way to discover some problems with a new angle.

This year, I’ve chosen C# because the language has evolved over the years. I also appreciate the community behind it.

To conclude, AI can write code, AI can generate a full application without any human intervention. But it’s important to be able to judge the output and it’s possible only if I have the competence to do the job. That’s why, keeping hands on, I continue to learn and practice programming “manually”.

Feature teams organization

Wed, 17 Sep 2025 00:00:00 +0200

When a tech company grows, teams organize themselves around technical divisions (front-end, back-end, infrastructure, DevOps…). This division is quite natural, as it brings groups with similar skills. But this organization isn’t without problems.

IMO, this organization has many downsides. Features are designed and split across multiple teams. Responsibilities are diluted, and teams can blame each other when problems occur. With this organization, there’s no global vision, teams don’t understand other teams’ challenges. It generates silos and company performance decreases.

High-performing teams organize themselves around functional splits. Each team is autonomous and fully responsible for a given domain. Those teams are multidisciplinary. Team members know everyone’s challenges. They move forward together toward a common goal. Responsibilities are no longer split. The whole team is responsible for the domain.

Autonomy is the key to ownership.

Focus on added value using AI

Mon, 18 Aug 2025 00:00:00 +0200

With AI, developers can focus on the essential: added value for users and software architecture.

Personally, I’ve been too much focused on code and technical quality. But with the AI, writing code becomes secondary, allowing us to concentrate on what really matters: solving user problems and create sustainable software architecture.

But AI should not be used without control. It should be a guide on what to implement and how. Developers should be architects and AI should only write technical implementations.

Named constructors as multiple constructors alternative

Tue, 28 Jan 2025 00:00:00 +0100

Unlike other programming languages, PHP does not allow for multiple constructors in a class. However, defining multiple constructors can be beneficial in various scenarios, such as creating an object from different data types. If this functionality is not available in PHP, named constructors can be used as an alternative solution.

What is a named constructor? It is a static method that we can use to create an object instance. These methods have the advantage of being more explicit than the basic constructor, as they can add meaning to the object’s construction.

Consider the following example:

readonly class Color
{
    public function __construct(
        public int $red,
        public int $blue,
        public int $green,
    ) {}
}

The previous code defines an object that stores a color. This color consists of three levels: red, green and blue. The main constructor fills in these corresponding values. However, sometimes it may be useful to create a color from its hexadecimal value. In this case, we could introduce a constructor called fromHexCode to do this task:

readonly class Color
{
    public static function fromHexCode(string $code): self
    {
        $code = ltrim($code, '#');

        $red = hexdec(substr($code, 0, 2));
        $blue = hexdec(substr($code, 2, 2));
        $green = hexdec(substr($code, 4, 2));

        return new self($red, $blue, $green);
    }

    public function __construct(
        public int $red,
        public int $blue,
        public int $green,
    ) {}
}

Named constructors can simplify object creation by providing default values based on the context. They also encapsulate the complex creation logic, making the code easier to read and understand.

This technique is also popular in Domain Driven Design. It can help clarify the business process that led to the data creation. For example, consider user registration in an application:

class User
{
    public static function fromRegistration(string $name, string $email, string $password): self
    {
        $user = new self($name, $email, $password);

        // additionnal business logic related to registration

        return $user;
    }

    public static function fromSocialLogin(string $name, string $email): self
    {
        $user = new self($name, $email);

        // additionnal business logic related to social login

        return $user;
    }

    private function __construct(
        public string $name,
        public string $email,
        public ?string $password = null,
    ) {}
}

This last example introduces a User class with a private constructor. To create an object instance, a named constructor must be used. The constructor choice will depend on the business context. This approach allows us to see user creation requirements depends on a specific use case.

When a user registers via the application, it should provide a name, an email and a password. However if the same user is logged through a social login, we only need the name and the email. The password is not necessary when using an external login system.

In summary, using named constructors can significantly improve the code base and enhance code readability. I highly recommend that you explore this technique as it under-exploited.

Test your Docker images

Tue, 29 Oct 2024 00:00:00 +0100

Do you build Docker images regularly? You certainly know that just because your image was built without errors, it doesn’t mean it works as you expect. Building a Docker image, like any code, must be verified and validated. As your code, you can write tests that will check your images.

The tool I personally use is called Container Structure Test. Developed by Google, it allows you to write unit tests for your Docker images. Written in Go, it’s available as a binary compatible with most operating systems.

With Container Structure Test, you will:

Run commands inside the container and verify the output or any errors produced,
Test file existence,
Check file contents (including its associated metadata),
Verify the configuration of the container itself.

Once downloaded, setting up tests is done by writing rules in a YAML file. Here’s an example configuration I use to test the construction of Docker images running PHP projects:

schemaVersion: "2.0.0"

# Vérification de la présence de certaines variables d'environnement
globalEnvVars:
    - key: GITHUB_TOKEN
      value: github-token

commandTests:
    - name: "Symfony CLI installed"
      command: "which"
      args: ["symfony"]
      exitCode: 0
    - name: "Check PHP extensions"
      command: "php"
      args: ["-m"]
      expectedOutput:
          - "amqp"
          # ...


fileExistenceTests:
- name: 'Configuration PHP'
  path: 'etc/php/8.3/php.ini'
  shouldExist: false

fileContentTests:
- name: 'Linux Version'
  path: '/etc/os-release'
  expectedContents: ["VERSION_ID=3.14.2","NAME=\"Alpine Linux\""]

When the setup is complete, you just need this command:

container-structure-test test --image my-registry.jdecool.fr/php:8.3 --config php-tests.yaml

=======================================
====== Test file: php-tests.yaml ======
=======================================
=== RUN: Command Test: Symfony CLI installed
--- PASS
duration: 306.265278ms
stdout: [...]

=== RUN: Command Test: Check PHP extensions
--- PASS
duration: 303.302806ms
stdout: [...]

=== RUN: Command Test: Configuration PHP
--- PASS
duration: 276.503651ms
stdout: [...]

=== RUN: Command Test: Linux Version
duration: 276.503651ms
stdout: [...]

=======================================
=============== RESULTS ===============
=======================================
Passes:      4
Failures:    0
Duration:    789.707605ms
Total tests: 4

PASS

Join me on Mastodon and Bluesky

Mon, 06 May 2024 00:00:00 +0200

I’ve been sharing technology and programming articles on X (Twitter) for several years.

Unfortunately, the Twitter ecosystem has been deteriorating, and more and more people migrate to alternatives.

That’s why, all my social publications are now also available on Mastodon and Bluesky.

Backing up your MySQL database without disturbing your production

Sun, 18 Feb 2024 00:00:00 +0100

In most cases, to back up a MySQL database, the mysqldump command is used (it’s the official utility provided by the database). But did you know that the command is risky and can disturb your production?

I recently experimented it when trying to back up a large database. Because by default, the tool will lock tables, making them inaccessible. If you don’t have a lot of data, there won’t impact. But otherwise, it can cause a service interruption for the duration of the operation.

To avoid this, mysqldump offers a number of options that can help you avoid these issues. The two most important I use systematically are:

--single-transaction: allow dumping the consistent state of the database at the time when START TRANSACTION was issued without blocking any applications,
--skip-lock-tables: avoid locking table when dumping it.

How to use PHPUnit 10 with Symfony

Tue, 10 Oct 2023 00:00:00 +0200

PHPUnit has been release 8 months ago (the 3rd of February 2023). But if we try to use it in a Symfony project using the symfony/phpunit-bridge component, a PHP Fatal error: Uncaught Error: Class "PHPUnit\TextUI\Command occurred.

PHP Fatal error:  Uncaught Error: Class "PHPUnit\TextUI\Command" not found in /home/jdecool/Workspace/sandbox/test/bin/phpunit:11
Stack trace:
#0 {main}
  thrown in /home/jdecool/Workspace/sandbox/test/bin/phpunit on line 11

Fatal error: Uncaught Error: Class "PHPUnit\TextUI\Command" not found in /home/jdecool/Workspace/sandbox/test/bin/phpunit on line 11

Error: Class "PHPUnit\TextUI\Command" not found in /home/jdecool/Workspace/sandbox/test/bin/phpunit on line 11

Call Stack:
    0.0001     396248   1. {main}() /home/jdecool/Workspace/sandbox/test/bin/phpunit:0

The Symfony script tries to use a deleted PHPUnit class. While there are several PRs to fix the problem, but none are currently merged.

If you want to solve this issue, you can simply update the bin/phpunit file using this patch:

-    PHPUnit\TextUI\Command::main();
+    exit((new PHPUnit\TextUI\Application)->run($_SERVER['argv']));

The meeting pertinence

Sun, 08 Jan 2023 00:00:00 +0100

This is not new, I’ve been hearing it for several years, everybody wants to limit meetings. One of the latest examples is Shopify, which is considering eliminating all recurring meetings with more than two people.

Yes, meetings can be unproductive and a waste of time for attendees. In reality, the cause is very often a lack of preparation. But there is something very important in meetings: meetings aim to communicate and collaborate.

When working on a team, I think it’s important and essential to have sometimes synchronous communication, where everyone can discuss, exchange, hear the same thing at the same time. This is what builds teams, contributes to cohesion and allows them to share a common vision. It’s not about working in isolation.

Indeed, this is not easy and one of the major problems is that there is always the same people who speak, sometimes they crush other people (even involuntarily). This is a bias that is not easy to avoid but we should be careful about it!

They are many techniques and tools to avoid traps. For me, I’m using a lot of agile tools, rituals and ceremonies.

About the code coverage

Tue, 03 Jan 2023 00:00:00 +0100

When starting to write unit tests in a project and we want to have some test metric, we usually start with the code coverage. This indicator is very used, but it’s also very criticized.

The code coverage is a measure of the executed source code lines during the test process. It means it counts the production code lines browses by tests. The problem is that lines are counted even if there is no test assertions.

For example, taking this code:

function calculate(string $op, int $x, int $y): int
{
    return match ($op) {
        '+' => $x + $y,
        '-' => $x - $y,
        '*' => $x * $y,
        '/' => $x / $y,
        default => throw new \InvalidArgumentException(),
    };
}

And its associated test:

class CalculatorTest extends TestCase
{
    public function testCalculateMethod(): void
    {
        $resultat = calculate('+', 1, 5);

        $this->assertIsInt($resultat);
    }
}

We obtain the following code coverage result:

Summary:
  Classes: 100.00% (1/1)
  Methods: 100.00% (1/1)
  Lines:   100.00% (7/7)

The test has no pertinent assertion, but we have 100% code coverage. That’s why code coverage is criticized.

This is also why we should consider code coverage as a project negative indicator and not as a quality indicator. A project with a bad code coverage indicates missing tests. Whereas, if it has a good code coverage, it is not enough to measure the test quality. We should complete it with other metrics.

Note that there is another metric related to the code coverage: the branch coverage. It consists to evaluate and check if each control structure (such as if or case statements) has been executed.

It we take our previous example, the branch coverage result would be:

Summary:
  Classes:  0.00% (0/1)
  Methods:  0.00% (0/1)
  Paths:    20.00% (1/5)
  Branches: 42.86% (3/7)
  Lines:    100.00% (7/7)

We can easily see the difference. Every line of code has been executed, but tests only explored one of the five possible execution paths. This clearly indicates that tests are not relevant because they cover a few behaviors.

As we saw, branch coverage is a better indicator than code coverage. Nevertheless, we should be careful as it is expensive to calculate (time, CPU, memory, …) and it can slow your test suite.

Travel in your PHP memory with PHP Meminfo

Mon, 27 Nov 2017 00:00:00 +0100

Do you really know how your PHP project consumes the memory ? If the answer is no, you should consider using PHP Meminfo.

PHP Meminfo is a PHP extension that gives you insights on the PHP memory content. Its main goal is to help you understand memory leaks: by looking at data present in memory, you can better understand your application behaviour.

The version 1.0.0 just released with PHP 7 support, more complete and better documentation.

If you are a macOS user and you use Homebrew as package manager, you can install the extension easily, as a package exists for each compatible PHP version.

Manage Composer dependencies in your monorepository project

Tue, 11 Jul 2017 00:00:00 +0200

Having a monorepository project means to get all applications and components at the same place. This post isn’t about the avantages or drawbacks of this project management strategy, a lot of developer blogged about the advantages or drawbacks. This post is about how to manage your Composer dependencies in the specific case of monorepository based project.

First, have a look of a project folder structure :

applications/
    api/
        composer.json
    backend/
        composer.json
    frontend/
        composer.json
    worker/
        composer.json
component/
    package1/
        composer.json
    package2/
        composer.json

The challenge is to define how the differents applications can easily use the 2 components package1 and package2. Maybe your first idea is to configure Composer autoloading to reference all components which are in the repository. This looks like :

{
  "autoload": {
    "psr-4": {
      "Vendor\\Package1\\": "../../component/package1/src",
      "Vendor\\Package2\\": "../../component/package2/src"
    }
  }
}

This method works, but it’s not the best solution because the composer.json file of different components is not used. And this is the file which is used to define components requirement and configuration. Furthermore, there is a duplication of autoloading configuration: in the components and in each application will used its.

If you read the Composer documentation, there is a concept of “repositories”. A repository is a package source. It’s a list of packages/versions. Composer will look in all your repositories to find the packages your project requires.

It’s possible to add new repository sources like github, gitlab or vcs and even more. The one which is very interestant in our case is path. This will allow to refer to a local repository of the computer.

We’re going to update our composer.json :

{
  "repositories": [
    {
      "type": "path",
      "url": "../../component/package1"
    },
    {
      "type": "path",
      "url": "../../component/package2"
    }
  ],
  "require": {
      "vendor/package1": "*",
      "vendor/package2": "*"
  }
}

Now, the Composer configuration refers to our local repository, we don’t need to override the component configuration, whereas Composer will load it as any other dependency.

While I made some search about the best way to manage Composer dependencies in a monorepository, I discovered an experimental project, which is an Composer plugin dedicated to manage this project structure. I didn’t test it, but it could be interesting. The project author have blogged about the tool.

RSS is dead, long life to JSONFeed

Wed, 31 May 2017 00:00:00 +0200

You may not know about it, but it want to replace the RSS format. The first version of new syndication format called JSONFeed was released on May 17, 2017.

The RSS format which is massively used since 1999 allow website to publish a news feed. It has evolved in 2003 to become a new format called Atom.

JSONFeed authors have noticed that JSON has become the developers’ choice for APIs, and that developers will often go out of their way to avoid XML. JSON is simpler to read and write, and it’s less prone to bugs. They developed JSON Feed, a format similar to RSS and Atom but in JSON. It reflects the lessons learned from our years of work reading and publishing feeds.

A new format that we must follow in the next months.

If you are a PHP developer, I start to create a library to read and write JSONFeed content. It is available on Github. Feel free to contribute.

I have also updated my website to allow you to follow updates throw a JSONFeed.

How to use Chrome Headless with Behat

Mon, 08 May 2017 00:00:00 +0200

Headless Chrome is shipping in Chrome 59 (currently in beta), it seems that we can use the browser without UI. It is very interesting for testing and automated purpose. In this post, we are going to configure Behat (a PHP framework for autotesting your business expectations) to use Chrome in headless mode.

This new Chrome feature interest a large part of the Web community. So much, that the maintainer of PhantomJS, a headless browser which is also based on Webkit, announced the end of the project. So, if you used this in your Behat scenarios, you should change the browser you used.

This is an sample of the Behat configuration I use for PhantomJS :

# behat.yml
default:
    extensions:
        # ...
        Behat\MinkExtension:
            base_url: http://project.dev
            sessions:
                default:
                    selenium2:
                        wd_host: http://localhost:4444/wd/hub

Now we have to make some change to be able to use Chrome browser. First, we have to add the ChromeDriver. Next, we need to add some configuration directory in our behat.yml file :

# behat.yml
default:
    extensions:
        # ...
        Behat\MinkExtension:
            base_url: http://project.dev
            sessions:
                default:
                    selenium2:
                        browser: chrome
                        wd_host: http://localhost:4444/wd/hub
                        capabilities:
                            chrome:
                                switches:
                                    - "--headless"
                                    - "--disable-gpu"

There are some little changes if the configuration file. We begin by defining the browser we want to use. Then we set up some capabilities (options that can add to customize and configure our Chrome session). We add the --headless argument to use the headless mode in combination to --disable-gpu which is temporarily needed for now.

Et voilà ! By adding 5 lines of configuration we have replaced the PhantomJS browser usage by Google Chrome with “headless” mode.

The full configuration file is available on Gist

How to use a Select2 input with Behat

Mon, 26 Sep 2016 00:00:00 +0200

If you are a PHP developer, you might know Behat, the most popuplar Behavior Driven Development (BDD) framework for PHP. Personnaly, I frequently annoyed when I have to write scenario with an UI which is using Select2, because it’s not possilbe to manipulate the field natively with Behat and the Mink extension.

To do this work, you need to create a new Behat context where you will add custom actions needed to control the Select2 list. Given there is a very few explanations on the subject, I decide to share the code to do that.

/**
 * @When /^(?:|I )fill in select2 input "(?P<field>(?:[^"]|\\")*)" with "(?P<value>(?:[^"]|\\")*)" and select "(?P<entry>(?:[^"]|\\")*)"$/
 */
public function fillInSelectInputWithAndSelect($field, $value, $entry)
{
    $page = $this->getSession()->getPage();

    $inputField = $page->find('css', $field);
    if (!$inputField) {
        throw new \Exception('No field found');
    }

    $choice = $inputField->getParent()->find('css', '.select2-selection');
    if (!$choice) {
        throw new \Exception('No select2 choice found');
    }
    $choice->press();

    $select2Input = $page->find('css', '.select2-search__field');
    if (!$select2Input) {
        throw new \Exception('No input found');
    }
    $select2Input->setValue($value);

    $this->getSession()->wait(1000);

    $chosenResults = $page->findAll('css', '.select2-results li');
    foreach ($chosenResults as $result) {
        if ($result->getText() == $entry) {
            $result->click();
            break;
        }
    }
}

If you are interested by manipulating a Select2 with Behat, please consider this Behat extension created and open sourced by my current company. It’s can be used with Composer and provide the most common feature for Select2. It’s also available on Github.