n8n is a process automation tool, with a particular focus on AI-related automations.

Its key features include:

• has a community (open source) version. Repository link
• written in TypeScript
• strongly resembles blueprint programming from Unreal Engine
• offers many ready-made nodes and integrations
• very easy to use (drag and drop)
• allows you to combine processes into sub-processes
• if you know BPMN, you’ll quickly understand how it works
• enables you to write code in the built-in editor using JavaScript and Python

Working with n8n

One of the most important things I realized while working with n8n was how crucial it is to ensure the correct structure of input and output data. It provides options for collecting, aggregating, and filtering data. Data processing is inherently iterative.

Writing code is quite convenient – there are suggestions and autocompletion. I had to adjust a bit and use JavaScript blocks to ensure proper hydration and data structure.

What can you use it for?

I think it’s great for:

• orchestration and automation of processes
• automating repetitive tasks
• quick integration of popular tools
• data synchronization

Example use case

With n8n, I automated the process of fetching new entries from an RSS feed and saving them to Google Sheets. Thanks to the ready-made integrations, it was enough to connect a few nodes, set up a schedule, and everything works automatically.

Drawbacks and limitations

During my tests, I noticed that:

• some integrations require additional configuration or API keys,
• the web interface can sometimes be less responsive with large workflows,
• the documentation is extensive, but not always detailed for less popular nodes.

Summary

n8n is a great tool for people who want to quickly implement automations without writing a lot of code. I especially recommend it to those who value flexibility and the ability to expand their own workflows.

Apache NetBeans

To begin, it is worth mentioning the history of Apache NetBeans. It is an integrated development environment that was originally created mainly for Java programming, but now supports several programming languages, including PHP. The general timeline is as follows:

• 1996 – At Charles University in Prague, a group of students starts the Xelfi project, one of the first Java IDEs written in Java.
• 1997-1998 – The Xelfi project is developed further, and its name changes to NetBeans.
• 1999 – Sun Microsystems buys NetBeans from the creators in Prague and begins official development, releasing it as open-source software.
• 2000-2010 – NetBeans develops rapidly, gaining support for new Java versions and other technologies. It becomes one of the most popular IDEs for Java developers.
• 2010 – Oracle acquires Sun Microsystems and thus becomes the owner of the NetBeans project.
• 2016 – Oracle decides to transfer NetBeans to the Apache Software Foundation, starting the project’s incubation process.
• 2018 – NetBeans officially becomes an Apache project and is named Apache NetBeans. The first version under the Apache name is released – Apache NetBeans 9.0.
• 2018-present – Apache NetBeans is actively developed by the open-source community. New versions are released regularly, supporting the latest technologies and programming languages.

Configuring NetBeans is relatively simple, though it requires a few steps: NetBeans can be downloaded directly from the Apache website. The installer is available for all popular operating systems. The most convenient way is to download Apache NetBeans directly from the repository.

After installation, it is worth reviewing the available plugins. NetBeans natively supports PHP, but you can install support for other languages. Above all, I recommend enabling the default PHP plugin.

Additionally, I recommend installing this plugin via GitHub: netbeans-php-enhancements or through the plugin portal plugin link.

To install a plugin, simply download and unpack it, then go to Tools -> Plugins -> Downloaded and select the file in the *.nbm format.

After installation, it should look as follows:

In the settings, you need to specify the path to the PHP interpreter

and enable additional options and hints for the latest plugin

Debugging

When it comes to debugging, we have the following option.

You also need to install the Xdebug Helper. and set the appropriate IDE key.

In the case of debugging with Docker, we can run the test code on Docker as follows:

docker compose exec -e XDEBUG_MODE=debug -e XDEBUG_CONFIG="start_with_request=trigger idekey=netbeans client_host=host.docker.internal client_port=9003" myServiceInDocker vendor/bin/phpunit'

Writing Code

When it comes to writing PHP code, you have to adjust a bit:

• importing all dependencies using the keyboard shortcut Ctrl + Shift + I instead of PHPStorm’s alt+enter. In my opinion, this is even better as it opens a dialog window where we can decide which dependencies we should import.
• searching using “Ctrl + I” in the top right corner
• switching between files using “Ctrl + PageUp” and “Ctrl + PageDown”
• php doc /** @var MyClass $myVariable */ works only in one line.

There are some quirks and borrowings from other IDEs. Ultimately, it can be used if you really want to. Netbeans also provides support for the Twig templating language. Syntax highlighting and auto-complete works, but unfortunately not much. Quick search does not work for Twig files and other similar files and requires appropriate modifications of PHP modules or extensions.

Advantages

• Lightweight – NetBeans is noticeably less resource-intensive than PHPStorm. It runs smoothly even on older computers.
• Open Source – Completely free, with no licensing restrictions.
• Support for multiple languages – Besides PHP, it handles Java, JavaScript, HTML, C/C++ very well.
• Built-in tools – Debugger, profiler, GIT integration, support for frameworks (e.g., Symfony, Laravel).
• Stability – It rarely crashes, and updates are regular.
• Simple configuration – You can quickly start working without having to install dozens of extensions.
• Extensibility - You can quickly start extending your IDE, surprisingly it’s much more convenient than in PHP
• Blast from the past - Interestingly, it’s a bit of a blast from the past and you can just feel like you did when programming once, when the IDE didn’t suggest everything
• Indexing process for PHPStorm - Currently, it’s simple and efficient enough to use without any problems.
• Contains a few unique ideas - Surprisingly, I found a few cool and useful things in it, like the task list or a slightly different style of working with the terminal.
• Ability to customize themes, keyboard shortcuts, and window layout.

Disadvantages

• Autocomplete – Works well, but requires the use of PHPDoc. In PHPStorm, the suggestions are more advanced and do not require such detailed documentation.
• Fewer plugins – The NetBeans community is smaller than, for example, VSCode, which limits the number of available extensions.
• Appearance – The user interface is somewhat outdated compared to the competition.
• No native integration with Docker – The environment has to be configured manually, which can be cumbersome when working with containers. PHP interpreter only in the native environment, you can’t connect it from Docker, which is a bit inconvenient.
• Static code analysis – It works, but it’s not as developed as in PHPStorm.
• Fewer educational materials – It’s harder to find up-to-date tutorials and community support.
• A bit outdated - In the general competition, it probably lacks a lot compared to its free alternatives. Especially Visual Studio Code, but I bet this will change over time
• No native support for Docker -
• Debugging - only on the server, if we want to debug scripts it’s already a bit more complicated and we have to tinker with it.
• GIT Integration - NetBeans has built-in GIT support, allowing convenient work with repositories directly from the IDE, but unfortunately, it doesn’t work as I expected, so I recommend getting used to working with the terminal. Probably, we have to wait for bug fixes.
• AI - lack of integration with copilot, there is a plugin that simulates it, but it’s not the same as in PHPStorm. It can just as well be a plus ;-)

Sample Applications

NetBeans is great for small and medium PHP projects, where we don’t need advanced refactoring tools or cloud integration. It’s ideal for people who value simplicity and stability, while still wanting access to basic IDE functions.

Tips and Tricks

• It’s worth using the “Live Templates” feature for quickly inserting repetitive code snippets.
• You can configure your own keyboard shortcuts, which significantly speeds up work.
• NetBeans allows for quick switching between files and classes (Ctrl+O, Ctrl+Shift+O).
• It’s important to regularly update the IDE and plugins - this improves stability and security.
• If you’re working with Docker, you’ll probably need to manually configure the environment.

My Experiences and Recommendations

After a few months of working with NetBeans, I can say that it’s a tool that allows you to focus on coding. It doesn’t distract with an excess of options, while still providing everything needed for daily work. If you’re looking for an alternative to heavy, paid IDEs - it’s worth trying NetBeans. I especially recommend it to those who value simplicity, stability, and open source. However, you need to be patient, as working with this IDE is quite different from current market solutions and gives the impression of a cumbersome tool. I’m sure that over time, the development of Apache NetBeans will speed up and it will start to constitute a real alternative to JETBrains products. Even though most of their products can already be used for free, time passes, companies change hands, and code remains.

And what about PHPStorm?

It’s not that PHPStorm is bad. It’s very good! You could also say that it’s even too good. What I like about software is the feeling that I have control over what I’m doing. Unfortunately, in the case of JetBrains products, I miss that. I’ve always liked to see what’s under the hood of the tools, the toys I used as a child, and I guess that’s how it’s going to stay with me.

Therefore, I decided to delve deeper into the issue of the IDE itself. However, the closed source code does not really encourage writing plugins. You really have to get into the documentation. Have knowledge in languages like Kotlin or Gradle. This is quite a high entry point for programmers who haven’t had much contact with Java.

From a user’s perspective, it’s a very good tool for those who are starting their programming journey with PHP. It has a lot of facilitating “automagic” features, which can give the impression that programming in it is very easy. Unfortunately, it’s not without a cost in computer resources. However, this also depends on how many “facilitations” we need in our work. It’s a very interesting business model, where we make the user dependent on our product. Sounds familiar, right?

The more we get, the easier it is for us, the more often we are willing to use this tool, even at a much higher price. Fortunately, in this case, you can always use a text editor and struggle with the place where you forgot to put a semicolon. Tears are shed… Meanwhile, people are already generating entire applications using modern AI tools.

Who knows, maybe IDEs should serve something similar. The most important things are ahead of us. Why PHPStorm may not be the best available IDE and, consequently, why it might be worth focusing on alternative options. I would like to take a look at the alternative in the form of Apache NetBeans in this post.

On a daily basis, programming tools can be a bit overwhelming. PhpStorm automatically installs a lot of resource-intensive plugins, such as:

• Github Copilot - a plugin that allows you to use GitHub Copilot conveniently. It’s quite useful, but its resource intensity with certain configurations can be problematic. And everyone has limited resources, especially if you’re programming on a laptop. In my opinion, it works much better in a limited context, when I use it from the web browser or just use the chat. However, it is useful in Agent mode for code generation. Usually, I ask it very silly things, or when I’m not sure if my approach makes sense. Well, because surely it has tried this before, right? Regarding the things I disabled from this plugin, it’s worth mentioning that the autocomplete can really eat up my laptop’s memory and it’s not that useful. You could even say that “Autocomplete” makes you look like an idiot, but that’s probably a topic for another post.

• Jetbrains Assistant - Nothing helps in programming like another AI assistant! Moreover, paid and from JetBrains. It is, in a sense, significantly better at debugging and suggesting than its competitor Copilot. No wonder, after all, it’s a certain area to be developed. Of course, as long as there are other products or services that offer similar services. However, it must be said that it needs to be looked into. It’s as resource-intensive as its competitor. It offers a pleasant and more readable interface and I can confidently say that it helped me solve several problems during my daily coding.

• Database Management - This explorer is really convenient. You can manipulate table views, quickly adjust the view, filters, and choose a suitable driver for your database. It summarizes the data very nicely and I can quickly see what I have inside. I can wholeheartedly recommend it if we care about a quick overview of the database. However, this client can also fail. In my case, it was the driver for the database when accessing the AWS MySQL database. I couldn’t delete a record or view the changes made. Tunneling is possible, but it needs to be configured correctly. Anyway, a solid 7/10! But nothing beats the magic of writing queries in the terminal.

• Docker - I don’t remember the last time I used it, because I do most things in the console.

• FTP - I usually only run this plugin to log into the server. I know I should use the terminal here. And I think I’ll quickly switch to the terminal. It’s worth mentioning the synchronization feature using rsync, it has really saved my skin when I had to quickly upload changes or fix a bug in production after a not-so-well-tested deployment.

• Symfony - a lot of useful functions, this is a plugin that I recommend. Especially for beginners and those learning the Symfony framework.

In summary, plugins are essential if we want to be productive, yet we gain more knowledge by not using these plugins as developers. By solving integration problems and directly interacting with the software, we can understand much better “what the author meant”. It’s a pity that I discovered this only recently. Better late than never!

Before I started the project, I had to disable unnecessary addons and restart my laptop five times. Additionally, I had to configure double the amount of memory on the Swap partition to even start screen sharing. I had to properly configure the entire project, ignore the appropriate folders, just to reduce the amount of memory used. This is really worrying, especially when working with larger projects. It delayed and bothered me in my daily work. One might suggest that most people work in PHP using a Mac, which can handle such loads without any problems. I wonder if it’s okay, especially since I only recently started measuring how much power my laptop can consume when running at full capacity. It ended up that after disabling most of the unused plugins and skipping the files generated by the applications, I was finally able to work normally. Probably, you also need to optimize not only the code that we write but also the tools that we use must be properly configured for this purpose. It’s a bit tempting to leave things as we found them.

Aside from the resource issues, the second important factor is that even if we have the ability to preview running processes, PHPStorm does many things automatically for us.

• Choosing the PHP version from the composer.json file,
• Installing dependencies.
• Fixing configuration errors for us.
• Auto-importing dependencies
• Task lists
• Debugging
• Code generation (with AI plugins)

So why did I decide to try switching to an older, free alternative?

Below is NetBeans and above is PHPStorm… it eats memory like a rabbit eats cabbage :-) This is certainly due to the fact that with great power comes even greater indexation process.

Fortunately, since PHP 7.3 you can use the so-called trailing comma, i.e., a comma after the last argument in function calls, function declarations, and arrays. Thanks to this, when you add a new argument, you don’t have to remember to manually add a comma at the end of the previous line.

🛑 Example without trailing comma

class User {
    public function __construct(
        string $name,
        int $age
    ) {
        // ...
    }
}

If you want to add another argument, you have to go back to the previous line and add a comma:

class User {
    public function __construct(
        string $name,
        int $age, // you have to add a comma
        string $email
    ) {
        // ...
    }
}

✅ Example with trailing comma

class User {
    public function __construct(
        string $name,
        int $age,
    ) {
        // ...
    }
}

Now you can simply add another argument without worrying about commas:

class User {
    public function __construct(
        string $name,
        int $age,
        string $email,
    ) {
        // ...
    }
}

📅 Since when?

Trailing comma in function and method argument lists is available since PHP 7.3. Previously, it was only available in arrays.

📝 Summary

Using the trailing comma:

• makes adding and removing arguments easier,
• reduces the risk of syntax errors,
• improves code readability in the long run.

It’s worth using this feature, especially in larger projects!

• building subarrays from various values

php > var_dump(array_map(static fn ($value) => ['numeric_string' => $value], ['zero','one','two','three']));
array(4) {
  [0]=>
  array(1) {
    ["numeric_string"]=>
    string(4) "zero"
  }
  [1]=>
  array(1) {
    ["numeric_string"]=>
    string(3) "one"
  }
  [2]=>
  array(1) {
    ["numeric_string"]=>
    string(3) "two"
  }
  [3]=>
  array(1) {
    ["numeric_string"]=>
    string(5) "three"
  }
}

• extracting values from another array and converting them to something else

$ids = array_map(static fn ($id) => ['id' => $id], array_values($ids));

• returning a new list of values with changed values, without modifying the old list

$newArray = array_map(static fn ($item) => str_replace('"','""',$item), $oldArray);

You can multiply the examples, but the most useful ones can be found here: link to PHP documentation

here is what I had in my project

{
  "autoload": {
    "psr-4": {
      "Ziumper\\App\\": "src/",
      "Ziumper\\App\\": "tests/"
    }
  }
}

but this way all may classes seems to be loaded inside composer autload map. I knew there must be better way to solve that. Here is what I figured out

{
  "autoload": {
    "psr-4": {
      "Ziumper\\App\\": "src/"
    }
  },
  "autoload-dev": {
    "psr-4": {
      "Ziumper\\App\\": "tests/"
    }
  }
}

Durring that time I got some really serious issues, I couldn’t declare Traits in my tests folder and it was quite hard feeling to copy paste all that code, then I moved forward with next version. Later I figured out that I had an issues with PS-4 autoloading inside shopware plugins. So I decided to move with following.

{
  "autoload": {
    "psr-4": {
      "Ziumper\\App\\": "src"
    },
    "exclude-from-classmap": ["tests"]
  },
  "autoload-dev": {
    "psr-4": {
      "Ziumper\\App\\Tests\\Utils\\": "tests/utils",
      "Ziumper\\App\\Tests\\Unit\\": "tests/unit",
      "Ziumper\\App\\Tests\\Integration\\": "tests/integration"
    }
  }
}

So how this works is:

• all base code declarations are stored inside src folder and those used for tests are inside tests\utils folder. Base test cases traits, data providers too.
• integration and tests are using src references and are giving me some nice working cases.
• exclude from classmap is a guard which stands in front of my testing code and doesn’t allow it to get into production loading flow.
• PSR-4 autoload in Composer loads classes by namespace → folder → filename.
• PHPUnit use PS-4 not auto generated class map.
• exclude-from-classmap = guards from loading my utility classes in production
• no need to write custom bootstrap loading

The class loading process may vary depending on the framework or rules used. For example, in shopware, plugins do not want to load Utils classes, for which you have to write with your own bootstrapper class.

Step 1: Add GitHub Copilot template to your repository

To get started, you need to add a GitHub Copilot template to your repository. This template will provide GitHub Copilot with the necessary context to generate commit messages. You can create a new file in your repository called .github/git-commit-instructions.md and add the following content:

# Git Commit Instructions

When making a commit, please follow these guidelines to ensure clarity and consistency in our commit history.
Provide description in the commit message.
* Describe the changes made in the commit and intended impact on the codebase in new lines.
* Make sure to include:
    * What was changed (e.g., added feature, fixed bug, updated documentation).
    * Why the change was necessary (e.g., to improve performance, fix an issue, enhance user experience).
    * Any relevant details that help understand the context of the change.
* Elaborate on the reasoning behind the changes and any relevant context that may help reviewers understand the
commit better.

This template provides guidelines for writing good commit messages and will help GitHub Copilot generate better commit messages.

Step 2: Use GitHub Copilot to generate commit messages

Once you have added the template to your repository, you can start using GitHub Copilot to generate commit messages. When you are ready to make a commit, you can use one of the following IDE editors that support GitHub Copilot:

• Visual Studio Code
• JetBrains IDEs (e.g., IntelliJ IDEA, PyCharm, WebStorm)
• Neovim

When you click the commit message editor button, GitHub Copilot will suggest a commit message based on the changes you have made and the guidelines provided in the template. GitHub Copilot will automatically suggest a commit message based on the changes you have made and the guidelines provided in the template.

Conclusion

Using GitHub Copilot to generate commit messages automatically can help you write better commit messages and improve your productivity. By adding a GitHub Copilot template to your repository and using one of the supported IDE editors that support GitHub Copilot, you can easily generate clear and informative commit messages. Give it a try and see how it can improve your workflow! I’m already using it and I love it! 😊

Have you ever wondered why developers stubbornly add an empty line at the end of files? Is it some secret tradition? Or maybe a way to fight boredom? The answer is more technical, but there’s a bit of history and… a touch of absurdity! 😄

Technical reasons 🛠️

1. POSIX Standard 🧑‍💻

Imagine POSIX as a strict teacher in the school of programmers. It says: “Every text file must end with a new line (\n). End of discussion!” Why? Because tools like cat, diff, or git love order. If a file doesn’t end with a new line, they might get upset and show weird results, e.g., merging the last line of one file with the first of another. It’s like two sentences in a book blending into one – chaos! 📚

POSIX (Portable Operating System Interface) was created to unify the behavior of operating systems. Thanks to this, programs can work predictably on different computers. And the empty line at the end of a file is a small gesture towards order and compatibility. ✨

2. Avoiding errors in PHP 🐘

In PHP, if anything appears after the closing ?> tag – even an innocent space or new line – the server might get angry and send HTTP headers at the wrong moment. The result? The page looks weird, and you spend half a day looking for the bug. The empty line is like a programmer’s lucky charm! 🍀

3. Better readability 👀

An empty line at the end of a file is like a period at the end of a sentence. Thanks to it, the code looks neat, and changes in version control systems are clearer. Git likes it when everything is in its place! 😎

4. PSR-2 and PSR-12 Standards 📏

And what does PHP-FIG, the programmers’ council of elders, say? They invented the PSR-2 standard, and then its younger, more demanding brother PSR-12. Both clearly state: there must be a new line at the end of the file! This way, your code complies with the guidelines, and your linter doesn’t have a panic attack. It’s a bit like following health and safety rules in code – nobody wants to get a ticket from the reviewer! 🚨

Historical reasons 🏺

In the past, text editors were moody. The lack of an empty line could cause errors during compilation or code interpretation. So developers learned to add this magic line to avoid surprises. It’s a bit like wearing socks with sandals – not always needed and considered a fashion crime, but sometimes it saves the day! 🧦

Twig 🕸️

In Twig files, the empty line helps avoid unwanted characters in the generated HTML. Thanks to this, your page doesn’t look like a patchwork of random spaces and enters. And version control systems? They’re grateful too! 🙏

Summary 🎉

Adding an empty line at the end of PHP and Twig files is not just a technical necessity, but also a part of programming culture. It protects against errors, keeps things tidy, and makes tools happy. So next time you add an empty line, you can feel like a code hero! 🦸‍♂️

What is the extra Section in composer.json?

The extra section is a special place in your composer.json file for custom configuration.
It is used by Composer plugins, frameworks (like Symfony), and scripts to store additional settings.

Example

{
  "extra": {
    "symfony": {
      "allow-contrib": true,
      "recipes": {
        "symfony/console": {
          "version": "1.0",
          "ref": "abcdef"
        }
      }
    }
  }
}

For what I used the extra section?

Well I used it to store Symfony Flex recipes. Symfony Flex is a Composer plugin that helps manage Symfony applications by automating the installation and configuration of packages. When you install a package that has a recipe, Symfony Flex adds configuration files and settings to your project automatically. You may prefer to remove some of these recipes if they are no longer needed or if you want to customize your setup. In my case it was docker setup that I didn’t need.

{
  "extra": {
    "symfony": {
      "allow-contrib": true,
      "docker": false
    }
  }
}

Symfony flex

The Flex recipes make a few assumptions about your project’s directory structure. Some of these assumptions can be customized by adding a key under the extra section of your composer.json file. For example, to tell Flex to copy any PHP classes into src/App instead of src:

{
  "...": "...",

  "extra": {
    "src-dir": "src/App"
  }
}

Troubleshooting

If you encounter issues after removing recipes, try the following steps:

• Run composer install to refresh your dependencies.
• Check for missing configuration files or environment variables.
• Review Symfony documentation for any manual steps required after recipe removal.

Additional Resources

• Symfony Recipes Documentation
• Composer Extra Section

I had this code:

public function getPercentage(): int
{
    // epsilon to avoid division by zero
    if (abs($this->limitPrice) < 1e-8) {
        return 0;
    }

    return min(100, (int) round(($this->totalCartPrice / $this->limitPrice) * 100));
}

And I started wondering:

• Can I just compare $this->limitPrice == 0.0?
• What if limitPrice = -0.0? 🤯

🔬 Analysis

1️⃣ IEEE 754 and -0.0

In the floating point standard, there is positive zero (0.0) and negative zero (-0.0).
At the byte level, they are two different values:

• 0.0 → 0x0000000000000000
• -0.0 → 0x8000000000000000

So yes, binary-wise, they are not the same.

2️⃣ How PHP Handles It

Compare this:

var_dump(0.0 == -0.0);   // true
var_dump(0.0 === -0.0);  // true

✅ PHP treats these two values as equal both with loose (==) and strict (===) comparison.

But watch this:

var_dump(1 / 0.0);  // float(INF)
var_dump(1 / -0.0); // float(-INF)

➡️ The difference shows up when dividing – the sign of zero affects the result (+∞ vs -∞).

3️⃣ Does It Matter in My Case?

In my code, limitPrice has at most 4 decimal places, comes from the database or simple operations.
I don’t have strange negative zeros coming from complex math.
So I can safely write:

if ($this->limitPrice == 0.0) {
    return 0;
}

And everything works just fine.
Epsilon (1e-8) is not needed here, because I don’t have rounding errors at the 17th decimal place.

🛠 Bonus: How to Detect -0.0 (For the Nerds)

If for some reason you must know whether it’s -0.0, here’s the trick:

function isNegativeZero(float $x): bool {
    return $x === 0.0 && 1 / $x === -INF;
}

var_dump(isNegativeZero(0.0));  // false
var_dump(isNegativeZero(-0.0)); // true

Yes, you actually divide by zero to detect it. 🧪

✅ Conclusion

• Yes, -0.0 and 0.0 are different bytes.
• PHP treats them as equal (==, ===).
• You can safely write == 0.0 in comparisons.
• Only division by 0.0 vs -0.0 returns different infinities (INF vs -INF) – so when dividing, you may want to use abs().

🎉 Summary

I managed to simplify my code and instead of epsilons I just have:

public function getPercentage(): int
{
    return $this->limitPrice ? min(100, (int) round(($this->totalCartPrice / $this->limitPrice) * 100)) : 0;
}

Cleaner, simpler, and still safe.
And the fact that -0.0 exists – well, that’s a great trivial fact to impress your fellow developers over coffee. ☕️😎

PS: If you need an epsilon, it’s better to use this constant:

PHP_FLOAT_EPSILON

🧐 The Problem

Let’s assume we have a method like this:

class MyService {
    public function doStuff(string $key, ?string $flag = null): string {
        return "Result: " . $key . ($flag ? " ($flag)" : "");
    }
}

And you want to test a class that uses MyService – of course, with a mock.
You use willReturnMap, because it’s elegant and works for multiple sets of arguments.

Sounds simple?
Let’s look at the test:

$mock = $this->createMock(MyService::class);

$mock->method('doStuff')
    ->willReturnMap([
        ['foo', 'Result: foo (bar)'],
        ['baz', 'Result: baz'],
    ]);

Looks good, right?
NOPE. 😅

💥 What happens?

If you don’t pass exactly as many arguments as the method takes, PHPUnit will say:

“I have no idea what you mean” 🤷‍♂️
and return null.

So when your production code calls:

$service->doStuff('baz');

the mock will say:

“Sorry, I don’t know that map.”

And your test explodes. 💣

🤯 Why does this happen?

Because willReturnMap matches arguments by position, exactly 1:1.
A default null argument isn’t magically “guessed”.
You need to explicitly put it in the array.

✅ The Correct Solution

You need to match the exact number of arguments, even if they’re default:

$mock->method('doStuff')
    ->willReturnMap([
        ['foo', 'bar', 'Result: foo (bar)'],
        ['baz', null, 'Result: baz'], // <--- null is required!
    ]);

Yeah, I know – seems obvious, but sometimes you hope for a bit of magic. 🪄
Sadly – PHPUnit offers no magic here.

📝 The Moral of the Story

• willReturnMap is great, but it’s very literal.
• If the method takes 2 arguments – your map must have 2 arguments.
• Even if the second argument defaults to null.
• PHPUnit isn’t a fortune teller – it won’t guess you meant the default. 😅

🎉 Takeaways

After this discovery, my tests stopped exploding.
Knowing that you have to explicitly provide every argument in the map saved me hours of debugging.
Now I know – with mocks, it’s better to provide one argument too many than one too few.

🧠 Key Point: willReturnMap ≠ flexible matching.
It’s a strict argument map – provide everything or don’t complain when your tests burn. 🔥

✍️ PS: If anyone finds a mention of this case in the PHPUnit docs – let me know.
I couldn’t find it, and I searched half the internet. 🙈

Link to documentation