<p>Recently ReactJS v18 was released. I started to look into its improvements, and checked which of my projects could benefit from them.</p><p>The main react-based project I maintain at the moment of writing this article is <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, so I naturally created a new branch and started the process.</p><p>The update was quite smooth, as most of the other dependencies I was using from the react ecosystem were already updated to support v18. All but one, <a target="_blank" rel="noopener noreferrer" href="https://enzymejs.github.io/enzyme/">enzyme</a>, the testing framework I was using to unit-test react components.</p><p>To be precise, I was able to continue running my tests, but some of them (those using <code>mount</code> instead of <code>shallow</code>) were still rendering components with the &quot;old&quot; React v17 approach, causing them to behave as in that version and a warning being printed in the console.</p><h3>First fix attempt</h3><p>The way enzyme integrates with the react version you are using is through an adapter library. The last official one supports only React v16, but someone released an <a target="_blank" rel="noopener noreferrer" href="https://github.com/wojtekmaj/enzyme-adapter-react-17">unofficial adapter for v17</a> which, with close to 650k weekly downloads, quickly became the way to go.</p><p>I checked if there was one for React 18, but sadly there wasn&#x27;t.</p><p>Also, the author of the adapter for v17 posted an article indicating <a target="_blank" rel="noopener noreferrer" href="https://dev.to/wojtekmaj/enzyme-is-dead-now-what-ekl">enzyme is dead</a>, he was not going to release one for v18, and publishing one for v17 was a mistake.</p><p>With those facts in mind, I started to face what was probably going to be the moment to migrate to <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/docs/react-testing-library/intro">react testing library</a>.</p><h3>Migration strategy</h3><p>I decided to follow a migration strategy similar to the one suggested in the article above, but with a couple of modifications:</p><ul><li>I update to React 18 anyway, as tests still pass.</li><li>Migrate right away all tests using <code>mount</code>, as those are the ones behaving differently.</li><li>New tests should be written directly with react testing library (RTL from now on).</li><li>When an existing test needs to be changed, consider migrating it to RTL, and do it if there&#x27;s time.</li><li>Introduce some PR from time to time just migrating a handful of tests.</li><li>Once everything is migrated, get rid of everything related with enzyme.</li></ul><h3>First contact and impressions</h3><p>I was a bit sceptical with RTL, as it was focused more on integration tests, instead of unit tests, which meant I had to completely change the mindset to write tests.</p><p>It also didn&#x27;t support shallow rendering, meaning that you will end up sometimes rendering a bigger component tree when testing container-like components, potentially causing side effects that could affect your test.</p><p>On the other hand there&#x27;s more and more people stating that <a target="_blank" rel="noopener noreferrer" href="https://kentcdodds.com/blog/why-i-never-use-shallow-rendering">shallow rendering is an anti-pattern</a>, and that&#x27;s probably the reason of enzyme getting &quot;discontinued&quot;.</p><p>Also, RTL has become the <a target="_blank" rel="noopener noreferrer" href="https://reactjs.org/docs/testing.html#tools">officially recommended framework</a> to test react components, it has become very popular, and it has even joined a wider group of testing libraries under the <a target="_blank" rel="noopener noreferrer" href="https://testing-library.com/"><code>@testing-library</code></a> organization.</p><p>The thing is that I started to use it, and I was quickly surprised with how it felt to work with it, and all the benefits it was bringing to my tests.</p><h3>Benefits I have experienced</h3><p>Once I started migrating the first tests I noticed some benefits:</p><ul><li>Changing my mindset was actually easier than I thought. The docs are very well written, so it&#x27;s relatively easy to start using RTL.</li><li>My tests got simpler, and required less of those nasty global mocks that jest allows (I&#x27;m looking at you, <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/es-ES/docs/mock-functions#mocking-modules"><code>jest.mock</code></a>).</li><li>Tests were way less coupled with implementation details. I moved from testing the component props, to test what the user would see on the screen.</li><li>Related with previous point, I started to write my tests by looking at the screen instead of the component&#x27;s implementation.</li><li>Changes in source code led to fewer tests requiring to be changed.</li><li>A progressive migration was possible, where some tests still use enzyme and others are already using RTL.</li></ul><p>And overall, it felt good and I have already dedicated a couple of PRs just to migrate more tests.</p><h3>Challenges I faced</h3><p>But of course, migrating to a new tool always comes with its own challenges, and this was not an exception. I&#x27;ll explain the main ones I have faced so far and how I tackled them:</p><ul><li><p>RTL lets you do some things in a couple of different ways, and the docs may not be super clear about what&#x27;s the recommended option.</p><p>For this I recommend reading <a target="_blank" rel="noopener noreferrer" href="https://acel.me/DCMb1">this article</a> from Kent C. Dodds, RTL&#x27;s author, which explains some common mistakes when using the library.</p></li><li><p>At first, I struggled a bit with asynchronous side effects and state changes in components, which can easily end up printing a warning like <code>Warning: An update to MyComponent inside a test was not wrapped in act</code>.</p><p>The warning also explains how you are supposed to solve this by wrapping your code in <code>act()</code>, but this warning comes from React, not RTL, and what it is not telling you is that RTL already wraps all needed operations in <code>act()</code>.</p><p>What this error usually mean is that you are not waiting for something to happen. <a target="_blank" rel="noopener noreferrer" href="https://acel.me/jnUdT">This other article</a>, also from Kent C. Dodds, explains everything you need to know about the things that can lead to this warning, and how to solve them.</p></li><li><p>Since you start testing from the user point of view, some use cases can be challenging to test without coupling with implementation details. For example, when you have a component which dynamically renders different images or icons, I used to directly check the component properties.</p><p>For this I found the best solution was to use <a target="_blank" rel="noopener noreferrer" href="https://jestjs.io/docs/snapshot-testing">jest snapshots</a>. I didn&#x27;t want to manually check which SVG was being rendered in the DOM, just that different ones were being used in every case.</p><pre><pre><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
  const wrapper = shallow(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
  expect(wrapper.find(FontAwesomeIcon).prop(&#x27;icon&#x27;)).toEqual(someIcon);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
  const { container } = render(&lt;MyComp dynamicValue=&quot;foo&quot; /&gt;);
  expect(container.firstChild).toMatchSnapshot();
})
</code></pre></pre></li><li><p>Something very similar happens if you use some library that renders canvas. There&#x27;s no way to test that from a DOM point of view, which is what RTL does.</p><p>In my case I was using <a target="_blank" rel="noopener noreferrer" href="https://www.chartjs.org/">Chart.js</a> to render some charts, so I used <a target="_blank" rel="noopener noreferrer" href="https://github.com/hustcc/jest-canvas-mock">jest-canvas-mock</a>, which exposes a method on the canvas to see which are all the events invoked from the library.</p><p>Then I used snapshots again to verify they had the expected &quot;shape&quot;.</p><pre><pre><code class="language-tsx">// I went from this...
test(&#x27;...&#x27;, () =&gt; {
  const wrapper = shallow(&lt;MyCompWithCanvas /&gt;);
  expect(wrapper.find(Chart).prop(&#x27;data&#x27;).datasets).toEqual(...);
})

// To this
test(&#x27;...&#x27;, () =&gt; {
  const { container } = render(&lt;MyCompWithCanvas /&gt;);
  const events = container.querySelector(&#x27;canvas&#x27;)?.getContext(&#x27;2d&#x27;)?.__getEvents();

  expect(events).toBeTruthy();
  expect(events).toMatchSnapshot();
})
</code></pre></pre></li></ul><h3>Conclusion</h3><p>For better or worst, enzyme should no longer be considered an option. If you are starting a new project or are using it on small ones, consider migrating to RTL as soon as possible.</p><p>If you are using it in bigger projects, following the process described in this article will probably help you.</p><p>In any case, you will get surprised. React testing library is a great tool and provides many benefits over enzyme.</p><p>Its main issue is that it&#x27;s not a drop-in replacement for enzyme, so you will have to change a bit your mindset.</p>

My experience migrating from enzyme to react testing library

<p>Capturing code coverage for a test suite is a very useful way to know which parts of your source code are actually getting executed by tests.</p><p>This is useful not only to know if you need to add more tests to your project (in case the coverage is too low), but also, if you want to apply technics like mutation testing, having a properly generated code coverage report will dramatically speed up te execution and help you know if a non-killed mutant is relevant.</p><h3>Generating the code coverage</h3><p>Capturing code coverage is usually easy in the most common types of tests, like unit tests, where the source code is executed in the same process.</p><p>Tools like <a target="_blank" rel="noopener noreferrer" href="https://phpunit.de/">PHPUnit</a>, one of the most extended PHP testing frameworks, ships with tools like <a target="_blank" rel="noopener noreferrer" href="https://github.com/sebastianbergmann/php-code-coverage">php-code-coverage</a>, designed to capture the code under execution, just by providing a couple of lines of configuration.</p><p>However, generating a reliable code coverage report is not always that easy for other types of tests.</p><p>In contexts like E2E tests, where you may spin-up an API on a different process, and make your tests just call this API via HTTP and assert on the responses, PHPUnit will not be able to capture the code coverage, because the source code is actually being loaded on a different process.</p><h3>Remote code coverage</h3><p>A couple of weeks ago, I faced the issue described above. I had a web service for which I had a decent API test suite, but I wanted to capture code coverage for two main reasons:</p><ul><li>Be able to merge this coverage with the one generated by other tests suites, to know what&#x27;s the &quot;total&quot; code coverage, regardless the test producing it.</li><li>Apply mutation testing to the API tests, as I was already doing that for the rest of the test suites in the project. For this, I also needed to know exactly what tests were covering every line of the source code.</li></ul><p>After some investigation, I couldn&#x27;t find a built-in feature, where PHPUnit itself was able to &quot;remotely&quot; capture te code under test, so I had to think on a way to manually use <code>php-code-coverage</code> by myself.</p><h3>Code coverage reports</h3><p>In order to be able to capture code coverage, I had to make sure the instances of the objects provided by <code>php-code-coverage</code> where &quot;spin-up&quot; with the server, and then, the code coverage report was dumped at the end.</p><p>Also, you usually define the code to include/exclude from coverage in PHPUnit&#x27;s config, but since this time we are the ones creating the coverage objects, this was not possible.</p><p>I tried a couple of different approaches (more on this at the end), but the most accurate one for me, was to define two routes in my server, that were dynamically configured only when running the server in the context of these tests, and were responsible for creating and dumping the code coverage.</p><pre><pre><code class="language-php">use PHPUnit\Runner\Version;
use SebastianBergmann\CodeCoverage\CodeCoverage;
use SebastianBergmann\CodeCoverage\Driver\Selector;
use SebastianBergmann\CodeCoverage\Filter;
use SebastianBergmann\CodeCoverage\Report\Html\Facade as Html;
use SebastianBergmann\CodeCoverage\Report\PHP;
use SebastianBergmann\CodeCoverage\Report\Xml\Facade as Xml;

// Define directories containing the code you want to cover
$filter = new Filter();
$filter-&gt;includeDirectory(...);
$filter-&gt;includeDirectory(...);
$coverage = new CodeCoverage((new Selector())-&gt;forLineCoverage($filter), $filter);

// This is &quot;pseudo-code&quot;. Defining the routes depends on the framework you use
$app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, function () use (&amp;$coverage) {
    $coverage-&gt;start(&#x27;API tests&#x27;);
    return new EmptyResponse();
});
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, function () use (&amp;$coverage) {
    $basePath = &#x27;...&#x27;; // Wherever you want the reports to be dumped
    $coverage-&gt;stop();

    // I generated coverage reports in a couple of different formats
    (new PHP())-&gt;process($coverage, $basePath . &#x27;/coverage.cov&#x27;);
    (new Xml(Version::getVersionString()))-&gt;process($coverage, $basePath . &#x27;/coverage-xml&#x27;);
    (new Html())-&gt;process($coverage, $basePath . &#x27;/coverage-html&#x27;);

    return new EmptyResponse();
});
</code></pre></pre><p>Then, I added the next snippet to my PHPUnit <code>bootstrap.php</code> file, to make sure the endpoints configured above are invoked at the proper times:</p><pre><pre><code class="language-php">// when starting up the test suite, call the endpoint to start collecting coverage
$httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/start-coverage&#x27;);

// When the tests process shuts down, call the endpoint to stop the coverage
register_shutdown_function(function () use ($httpClient): void {
    $httpClient-&gt;request(&#x27;GET&#x27;, &#x27;http://localhost:8080/api-tests/stop-coverage&#x27;);
});
</code></pre></pre><blockquote><p>Learn more about how to configure PHPUnit&#x27;s <a target="_blank" rel="noopener noreferrer" href="https://phpunit.readthedocs.io/en/9.5/configuration.html#the-bootstrap-attribute">bootstrap script</a>.</p></blockquote><p>This was fine from a pure code coverage point of view, but if you try it yourself, you will notice the report says all the code has been covered by <code>API tests</code>, which is what we provide when calling <code>$coverage-&gt;start(&#x27;API tests&#x27;);</code></p><p><img src="/assets/img/remote-coverage/invalid-api-coverage.png" alt="Invalid API coverage"/></p><p>To properly do mutation testing we need to know which are the exact tests that cover every part of the code. That requirement took me to the next approach.</p><h3>Supporting mutation testing</h3><p>To be more precise with the generated reports, I needed some way to notify the server about the specific test performing the request.</p><p>One way to do this is by sending a custom header when performing a request from your tests, and registering some event handler or middleware which starts the coverage for that request with the value coming from that header.</p><p>With that, I evolved the configuration above, and added a middleware handler (the framework I use is <a target="_blank" rel="noopener noreferrer" href="https://www.php-fig.org/psr/psr-15/">PSR-15</a> based, but the framework of your choice will probably have a way to do this).</p><pre><pre><code class="language-php">use ...

$coverage = new CodeCoverage();

// This ensures the coverage is started and stopped on every request, using the &quot;x-coverage-id&quot; header as the ID.
$app-&gt;middleware(function (ServerRequestInterface $req, RequestHandlerInterface $handler) use (&amp;$coverage) {
$coverage?-&gt;start(&#x27;API Tests&#x27;);
    $coverage-&gt;start($req-&gt;getHeaderLine(&#x27;x-coverage-id&#x27;));

    try {
        return $handler-&gt;handle($req);
    } finally {
        $coverage-&gt;stop();
    }
});

// This route is no longer needed. You can also remove the request from your bootstrap script
// $app-&gt;get(&#x27;/api-tests/start-coverage&#x27;, ...);
$app-&gt;get(&#x27;/api-tests/stop-coverage&#x27;, ...);
</code></pre></pre><p>Then, inside your test you can do something like this:</p><pre><pre><code class="language-php">use PHPUnit\Framework\TestCase;

class MyApiTest extends TestCase
{
    private ClientInterface $httpClient;

    public function setUp(): void
    {
        $this-&gt;httpClient = ...;
    }

    public function testMyEndpoint(): void
    {
        $resp = $this-&gt;httpClient-&gt;request(&#x27;POST&#x27;, &#x27;...&#x27;, [
            &#x27;headers&#x27; =&gt; [
                &#x27;x-coverage-id&#x27; =&gt; static::class,
            ],
        ])

        // Asserts go here...
    }
}
</code></pre></pre><p>After this, the code coverage reports will properly show the actual tests covering them.</p><p><img src="/assets/img/remote-coverage/valid-api-coverage.png" alt="Valid API coverage"/></p><h3>Alternative approach</h3><p>The approach explained here is functional, but it&#x27;s a bit hacky. I had to do it like this because of limitations with how I serve the API with <a target="_blank" rel="noopener noreferrer" href="https://openswoole.com">openswoole</a>.</p><p>However, instead of defining routes that need to be actively called to start/stop the code coverage (or just to dump the report, as in the second approach), you could try to register the shutdown function directly in the server side.</p><p>If that works for you, it&#x27;s much more straightforward, and you won&#x27;t need to bother changing your tests bootstrap script.</p><h3>Conclusion</h3><p>Even though there&#x27;s room for improvement, this allows to generate code coverage reports for code that&#x27;s running on a different process.</p><p>I plan to apply something similar for E2E tests for a command line app, so maybe I extend this article at some point.</p><p>Also, I decided to write this article, because at the moment of having to implement this myself, I didn&#x27;t find too much useful information out there.</p><p>I hope this helped you, and now you can collect code coverage reports on your API tests.</p>

Capturing remote code coverage in API tests with PHPUnit

<p>In the last couple of days I have been playing around with the idea of combining GitHub Actions and GitHub Pages to be able to dynamically build preview environments every time a pull request is opened against a repository hosting a client-side web app.</p><p>The idea is that you can quickly preview the changes made by some contributor, without having to clone their branch and running everything locally, something specially useful for open source projects.</p><p>In this article I will explain how to set everything up, and what are some considerations and problems you may face during the process.</p><h3>Enable github pages</h3><p>The first thing you need to do is enable your project to publish pages on some branch. I recommend creating a new branch for this, let&#x27;s say <code>preview-env</code>, and then enabling publishing on it.</p><p>In order to do that go to your repository and then <strong>Settings</strong> -&gt; <strong>Pages</strong>, look for the <strong>Source</strong> section, and you should see something like this:</p><p><img src="/assets/img/preview-envs/github-pages-before-enabling.png" alt="GitHub pages before enabling"/></p><p>Click in the dropdown and select your new branch, <code>preview-env</code>. Then click <strong>Save</strong>.</p><p><img src="/assets/img/preview-envs/github-pages-after-enabling.png" alt="GitHub pages after enabling"/></p><p>After saving you will see a message at the top of this section telling you what&#x27;s the URL in which the pages are published. It always follows the same pattern. If your organization is <code>my-org</code> and your repository is <code>my-repo</code>, the url will be <code>https://my-org.github.io/my-repo/</code>.</p><h3>Configure the workflow</h3><p>Now we need to configure a workflow that will &quot;deploy&quot; the preview environment for the branch every time a new pull request is created or updated:</p><p>Let&#x27;s imagine we have a React web app that is built with node.js. The configuration could look like this.</p><pre><pre><code class="language-yml"># .github/workflows/deploy-preview.yml
name: Deploy preview

on:
  pull_request: null

jobs:
  deploy:
    runs-on: ubuntu-20.04
    continue-on-error: true
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Use node.js 14.15
        uses: actions/setup-node@v1
        with:
          node-version: 14.15
      - name: Generate slug
        id: generate_slug
        run: echo &quot;##[set-output name=slug;]$(echo ${GITHUB_HEAD_REF#refs/heads/} | sed -r &#x27;s/[~\^]+//g&#x27; | sed -r &#x27;s/[^a-zA-Z0-9]+/-/g&#x27; | sed -r &#x27;s/^-+\|-+$//g&#x27; | tr A-Z a-z)&quot;
      - name: Build
        run: npm ci &amp;&amp; npm run build
      - name: Deploy
        uses: JamesIves/github-pages-deploy-action@4.1.1
        with:
          branch: preview-env
          folder: build
          target-folder: ${{ steps.generate_slug.outputs.slug }}
      - name: Publish env
        uses: marocchino/sticky-pull-request-comment@v2
        with:
          header: Preview environment
          message: |
            ## Preview environment
            https://my-org.github.io/my-repo/${{ steps.generate_slug.outputs.slug }}/
</code></pre></pre><blockquote><p>If you are not familiar with GitHub Actions yet, take a look at the <a target="_blank" rel="noopener noreferrer" href="https://docs.github.com/en/actions">official documentation</a>.</p></blockquote><p>This workflow will follow the next steps:</p><ul><li>Checkout the code from the repository.</li><li>Set-up node.js 14.15</li><li>Based on the branch name, generate a slug that we will use to have separated deployment folders for every pull request we receive. The slug is exposed to next steps as an output.</li><li>Build the project. This step will obviously depend on the needs of your project.</li><li>Using <a target="_blank" rel="noopener noreferrer" href="https://github.com/JamesIves/github-pages-deploy-action">JamesIves/github-pages-deploy-action</a>, deploy the contents we previously built in the GitHub page, under a sub-folder matching the slug we generated a few steps above, and under the branch <code>preview-env</code> (remember we enabled GitHub pages for this branch).</li><li>Finally, using <a target="_blank" rel="noopener noreferrer" href="https://github.com/marocchino/sticky-pull-request-comment">marocchino/sticky-pull-request-comment</a>, post a comment in the pull request with a link to the preview environment, so that you can just click on it and see the deployment.</li></ul><p>The steps may change depending on your needs and how you build your project. For example, I have an extra step to update a property in the <code>package.json</code> that is then used to allow serving the app in a sub-path instead of the root of the domain.</p><p>You may also not build your site with node.js, as you could be using any of the multiple existing static site generators out there, but you get the idea.</p><p>Finally, you have probably noticed the config includes <code>continue-on-error: true</code>. This will allow the pull request to be merged even if this process fails for some reason.</p><h3>Considerations when using forks</h3><p>While the configuration above will work perfectly when creating pull requests inside the same repository, there are some limitations when the pull request comes from a fork (which is the usual in OSS projects).</p><p>For security reasons, the <code>GITHUB_TOKEN</code> injected in those cases doesn&#x27;t have write permissions, which will make the &quot;deploy&quot; step fail.</p><p>Also, you cannot define your own token with more permissions and inject it as a secret, as the secrets are not exposed to workflows running on forks.</p><p>However, with a couple small config changes, we can work around these limitations:</p><h4>Change event</h4><p>The first thing we need to do is use the <code>pull_request_target</code> event instead of the <code>pull_request</code> one.</p><pre><pre><code class="language-diff">on:
-  pull_request: null
+  pull_request_target: null
</code></pre></pre><p>According to the documentation, this is equivalent to the <code>pull_request</code> event, but it runs in the scope of the base repository.</p><p>Thanks to this, the <code>GITHUB_TOKEN</code> will come with write permissions, and we will have access to secrets if needed.</p><h4>Checkout the fork</h4><p>The second thing we are going to change is that we now need to specify the repository to checkout.</p><p>In order to do that, we need to add two inputs to the &quot;Checkout code&quot; step, like this:</p><pre><pre><code class="language-diff">    steps:
      - name: Checkout code
        uses: actions/checkout@v2
+       with:
+         repository: ${{ github.event.pull_request.head.repo.full_name }}
+         ref: ${{ github.event.pull_request.head.ref }}
</code></pre></pre><p>This will ensure we checkout from the fork repository, instead of the base one, which is the default, as it&#x27;s the one where the <code>pull_request_target</code> event is scoped to.</p><p>And that&#x27;s it. With these two changes you can now deploy preview environments for pull requests coming from forks.</p><blockquote><p><strong>IMPORTANT!</strong> The limitations of the <code>pull_request</code> event are there for a reason. People could potentially get access to your secrets or manipulate your code. Proceed at your own risk.</p></blockquote><h3>Other considerations</h3><p>Other than the limitations for forks, there are a few other minor things to take into consideration.</p><ul><li>Changes in GitHub Pages do not reflect immediately. It may take up to a couple of minutes for the deployment to be available, but considering you will usually not review a PR right after it has been created, this should not be a big issue.</li><li>As you have seen, every time a pull request is created, the deployment will generate a new folder in your GitHub Pages branch. This may result in a lot of old folders to pile-up, so you may want to set up some way to clean them up periodically or after the pull request has been merged.</li><li>Due to the fact that GitHub Pages only allows static pages to be served, this process cannot be used with apps that require some kind of back-end or server-side logic.</li><li>If your project is already using GitHub Pages for something else (serve the project&#x27;s website or docs), that may conflict with this, preventing you from having this kind of preview envs.</li></ul>

Setting-up a preview environment for your client-side apps with GitHub Actions and GitHub Pages

<p>I remember many years ago, when I released my first open source project, that every time I had a new release ready, I was never sure what should be the new version number.</p><p>Versioning software is not as straightforward as it might look when you don&#x27;t have a lot of experience.</p><p>In this article I&#x27;ll try to explain the <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">SemVer</a> approach to version software, and some things you might want to take into account on top of that.</p><h3>Semantic Versioning</h3><p>The first thing you need is a solid set of rules that help you decide which should your next version be.</p><p>I remember thinking <em>&quot;is this version big enough as to jump from 1.0 to 2.0?&quot;</em> or <em>&quot;I have seen projects using three numbers for the version, X.Y.Z, should I do the same?&quot;</em></p><p>Those questions are easier to answer if you stick to some standard that tells you what to do, and that will help others more easily understand your intention.</p><p>My recommendation is to use <a target="_blank" rel="noopener noreferrer" href="https://semver.org/">Semantic Versioning</a>, as it defines a solid starting point, and it&#x27;s quite adopted by the community.</p><p>Semantic Versioning states that you should use three numbers to identify versions, <code>MAJOR.MINOR.PATCH</code>, and follow these rules in order to decide which one to increase:</p><ul><li><code>PATCH</code>: the new release includes only bug fixes. People are encouraged to update to this release and no changes are needed in their code bases.</li><li><code>MINOR</code>: the new release includes new backwards-compatible features. People can update to this version without changing their code bases, and make use of the new features afterwards if they wish.</li><li><code>MAJOR</code>: the new release includes <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Backward_compatibility">backward compatibility</a> breaks. Changes in the code base will be needed when updating to this version.</li></ul><blockquote><p>These rules are easier to apply to libraries and frameworks than it is for apps and services. More about this later.</p></blockquote><h3>Try to keep backwards-compatibility</h3><p>Ok, we have some rules now. However, I have seen very frequently people mistaking what <em>can</em> be done with what <em>should</em> be done.</p><p>Yes, if you introduce a breaking change, you can update the major version and that&#x27;s it. However, if you do it too frequently, people won&#x27;t be happy, and you will end up with a fragmented user base, that stop updating to newer versions.</p><p>I remember using a library to deploy stuff that had a new major version every couple of months, changing things like &quot;The <code>host</code> function is now called <code>server</code>&quot;. Yes, ok, but why do I have to change my stuff so frequently.</p><p>It&#x27;s usually better to try to implement things in a backwards-compatible way, and keep track of the things you want to change and do it all at a time.</p><p>You can also deprecate things, and document the way you want those things to be done moving forward. That way you give people the chance to start changing their code and simplify a hypothetical upcoming major release.</p><h3>Provide clear upgrade paths</h3><p>As mentioned above, too frequent major version changes are not desirable, but sooner or later you will want to release a new major version for different reasons.</p><ul><li>Getting rid of that feature which is hard to maintain, introduces lots of bugs, and provides little value.</li><li>Supporting something new which is very hard to implement without breaking backwards compatibility.</li><li>Removing all those deprecated methods you have been dragging for months.</li><li>Fix design issues, where something was architected in the wrong way, and only spotted after some time.</li></ul><p>At the time this happens you will want your users to upgrade to the newer version, as you don&#x27;t want people to report bugs that only affect older versions, or to expect you to backport fixes to older versions because they haven&#x27;t updated to the new one.</p><p>The best way to achieve this is to provide clear and simple upgrade paths:</p><ul><li><p>Prepare your releases for the things to come: If you want to introduce new ways of doing things, do it before the major release, and deprecate the older ones. For example, you can have a new method that gets called by an older one, while you mark the old one as deprecated.</p><p>People will be more willing to update and change their code afterwards. By the time the major release is published, their code will be ready to upgrade.</p></li><li><p>Include a CHANGELOG file in your project, explaining the changes introduced in every version. A very good way to document a change log is the <a target="_blank" rel="noopener noreferrer" href="https://keepachangelog.com/">Keep a changelog</a> initiative.</p><p>You can also use some other platform to document the change log, like GitHub releases.</p></li><li><p>Include documentation on how to upgrade to a major release: This is probably the most important one. Document all the steps that need to be followed and all the required changes to update from a release to the next major one.</p><p>A good way to do this is by including an UPGRADE file in your project. You can see <a target="_blank" rel="noopener noreferrer" href="https://github.com/acmailer/acmailer/blob/main/UPGRADE.md">this example</a>.</p></li></ul><h3>Versioning libraries vs apps</h3><p>Semantic Versioning is a good standard to version software, but it plays much better with libraries and frameworks that are installed using some kind of package manager, than it does with apps and services that are not directly depended on.</p><p>For example, how do you identify a backward compatibility break on a web user interface?</p><p>With this kind of software there are more grey areas, and you will end up using your intuition.</p><p>For example, not long ago I released a <a href="/2020/12/24/released-shlink-web-client-v3-0-0/">new major version</a> for a web app I maintain, and it was completely compatible with the previous one. However, it introduced a larger amount of features than usual, and big UI changes, so I decided it was worth the bump.</p><p>Because of this there are projects that use different approaches to version apps. For example:</p><ul><li>Firefox and Chrome have 6-week cycles, and after each one of them they release a new major version no matter what.</li><li>Jetbrains publishes a few releases of their IDEs every year (I think 3) which always start with the year they were released on, like <code>2020.3.0</code>, and they increase the patch number for bugfixes.</li><li>Ubuntu releases 2 versions every year, one in April and one in October, and they are always identified by the year and month they were released on, like <code>19.04</code> or <code>20.10</code>.</li></ul><h3>Special versions</h3><p>There&#x27;s also a set of special versions that can be used to publish the so-called <strong>pre-release</strong> versions. These <a target="_blank" rel="noopener noreferrer" href="https://semver.org/#spec-item-9">are covered</a> by Semantic Versioning, but sometimes they are not so easy to understand.</p><p>It is also very likely that you never have to use these, as only relatively big projects will need this level of granularity, but it&#x27;s still good to know what&#x27;s their purpose and what do they imply.</p><h4>0.x.y</h4><p>It is possible to release a version of your software where the major number is <code>0</code>. When this happens, it means your software is still in its early stages.</p><p>It does not mean it&#x27;s necessarily unstable, but it means you are still introducing frequent changes on it, and therefore, it might be a bit more fragile than a version starting with a number greater than <code>0</code>.</p><h4>Alpha</h4><p>The intention of an alpha release is that a subset of people con test some new functionality, but you don&#x27;t want people to use it in production</p><p>Alpha versions are on their very early stages. Their public API is very likely to change, and they probably contain bugs.</p><p>Semantic Versioning states that alpha versions are identified by this pattern: <code>MAJOR.MINOR.PATCH-alpha.NUMBER</code>, for example <code>2.0.0-alpha.1</code>.</p><h4>Beta</h4><p>Similar to alpha versions, beta versions are also prone to contain bugs, but their API will in theory not change. That means that you could potentially adapt your software to start using a beta version, and when the corresponding stable release is published, you shouldn&#x27;t need that many changes.</p><p>Semantic Versioning defines a pattern similar to the one for alpha versions: <code>MAJOR.MINOR.PATCH-beta.NUMBER</code>, for example <code>2.0.0-beta.1</code>.</p><h4>Release candidate</h4><p>Release candidates (RC) are pre-release versions that you will want to publish for the general user-base to test an upcoming release. You want to publish a RC so that it&#x27;s battle tested by as many people as possible, in order to find possible bugs and edge cases.</p><p>They should not contain many bugs, but some could be found. The public API should not change anymore.</p><p>According to Semantic Versioning, the pattern to identify a RC is <code>MAJOR.MINOR.PATCH-rc.NUMBER</code>, for example <code>2.0.0-rc.1</code>.</p><h3>Conclusion</h3><p>We have seen some approaches and considerations to properly version your software.</p><p>Versioning is not so straightforward when you don&#x27;t have a lot of experience, but as you have seen, you just need to know a small set of rules and use a bit your intuition.</p><p>With those tools, you will be able to properly version your software.</p>

What to take into account when versioning software

<p>Two days ago I released the first major version in almost 2 years for <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlink-web-client</a>, a web UI for <a target="_blank" rel="noopener noreferrer" href="https://shlink.io">shlink</a>, my self-hosted URL shortener.</p><p>This new version introduces several improvements to the project, and I thought it was worth writing a post to explain all of them in depth.</p><h3>New design</h3><p>The project has been using the same design almost since the beginning. It was clean, but it laked a bit of contrast and consistency in many sections.</p><p>Now the main background is light-gray, with components composed in white cards with a slight box shadow, that makes them easier to spot inside the app.</p><p>Also, the main area has now a max-width that prevents components from stretching too much on wide screens.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/design-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/design-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Overview page</h3><p>Up until now, after connecting to a Shlink server, you went directly to the list of short URLs.</p><p>With this new version, you now see an overview page first, which displays some general stats, a quick short URL creation form, and the latest 5 short URLs.</p><p>From there, you can navigate to the full list of short URLs, with filtering capabilities, or go to the advanced short URL creation form.</p><div class="row"><div class="col-md-8 col-md-offset-2 "><img alt="Overview" src="/assets/img/shlink-web-client-3/overview.png" class="gallery-item"/><p class="text-center"><small>Overview</small></p></div></div><h3>Improved short URL creation form</h3><p>One of the sections with more room for improvement was the short URL creation form. It had all the inputs mixed, displaying just the &quot;long url&quot; one, with the option to un-collapsing the rest at will.</p><p>The new design groups the inputs by context, which makes it more clear. It also displays the inputs all the time, since the &quot;quick form&quot; is now located in the overview page.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/creation-form-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/creation-form-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Enhanced visits page</h3><p>The visits page had a problem, it was trying to display too much information in a single place.</p><ul><li>Visits over time</li><li>Visits from every platform</li><li>Visits from every location</li><li>A list of visits as a table</li></ul><p>The new approach splits those in subsections with their own sub-route each (<code>/by-location</code>, <code>/by-context</code>, etc). This helps to render a smaller amount of charts at once, since they are a bit CPU greedy.</p><p>Also, only the visits from the last 30 days are loaded by default, making it load way faster for URLs with a lot of visits.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/visits-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/visits-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Outer sections</h3><p>The app has some sections which are not related to a specific server, like creating/editing servers, or the settings page.</p><p>These sections have also been adapted to the new style, and they also have a max-width for wide screens.</p><div class="row"><div class="col-md-6  "><img alt="Before" src="/assets/img/shlink-web-client-3/create-server-before.png" class="gallery-item"/><p class="text-center"><small>Before</small></p></div><div class="col-md-6  "><img alt="After" src="/assets/img/shlink-web-client-3/create-server-after.png" class="gallery-item"/><p class="text-center"><small>After</small></p></div></div><h3>Date range selector</h3><p>A new component allows selecting date ranges either by relative time ranges (last 30 days, last 90 days...) or by selecting absolute start and end dates.</p><p>This component is used to filter both short URL lists and visits lists.</p><div class="row"><div class="col-md-6  col-md-offset-3"><img alt="Date range selector" src="/assets/img/shlink-web-client-3/date-range-selector.png" class=""/><p class="text-center"><small>Date range selector</small></p></div></div><h3>Domain selector</h3><p>Shlink has had multi-domain support for some versions, but changing the domain from the web client required to set the value manually, which is a bit error-prone.</p><p>This version introduces a new component which allows selecting from domains already used in the past (which is what you will want in most of the cases), preventing accidental typos.</p><p>It also allows setting new values in case you want to use a new domain that you never used before. This domain will then appear in the list the next time.</p><div class="row"><div class="col-md-6  "><img alt="Existing domains" src="/assets/img/shlink-web-client-3/domains-existing.png" class=""/><p class="text-center"><small>Existing domains</small></p></div><div class="col-md-6  "><img alt="New domain" src="/assets/img/shlink-web-client-3/domains-new.png" class=""/><p class="text-center"><small>New domain</small></p></div></div><h3>Other improvements</h3><p>The changes described so far were the major ones. However, v3.0.0 includes a few other minor improvements.</p><ul><li>Result and loading messages have been standardized: They are now more consistent and use the same set of components, which also ensures consistency in the future.</li><li>Error messages are now more descriptive: Instead of showing generic error messages when API calls fail, the actual error message is now always displayed, so that it&#x27;s easier to know what failed.</li><li>Dropped support for Shlink v1: All major versions come with some breaking changes that improve code maintainability. This one drops Shlink v1 support, which allows removing some conditional paths here and there.</li></ul><p>Other than the last point, Shlink v3.0.0 is mostly backwards compatible, so it&#x27;s safe to upgrade if you are already using Shlink v2.x</p><h3>Next steps</h3><p>Of course this doesn&#x27;t end here, and I have a lot of ideas to improve it even further.</p><ul><li>Dark theme: It&#x27;s what the cool kids do these days, and I have already done some experiments around it.</li><li>Shlink dashboard: Next gen web app for Shlink. You can read the whole reasoning in <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client/issues/338">this issue</a>.</li><li>Filtering in lists added to URL: Many sections allow filtering lists, but the state is saved in memory, which means it gets lost if the page is refreshed, and it cannot be bookmarked. The intention is to make all filtering params to become part of the URL.</li><li>Exporting visits in CSV: It&#x27;s cool to see charts full of info, but sometimes admins need to feed other services with the data, and consuming the original API is not always an option. Exporting visits to a CSV file will be supported soon by shlink-web-client.</li></ul>

Released shlink-web-client v3.0.0

<p>For a long time, I have been trying to include tests in every project in which I&#x27;ve worked on.</p><p>There are several types of automated tests (or what should actually be called <a target="_blank" rel="noopener noreferrer" href="https://abstracta.us/insights/guide-continuous-testing/automated-checks">automated checks</a>). From unit tests, integration and functional tests, to end-to-end tests.</p><p>Each one of them differs from the rest by the scope they try to cover. From small units of code which are tested completely detached from external dependencies, to a whole app which is tested as a black box like if an end consumer was using it.</p><p>I&#x27;m not going to deeply discuss the semantics behind this, or where an integration test ends and an end-to-end test starts, because it&#x27;s quite frequently a blurry line.</p><p>I want to focus on unit tests, and a frequently used practice (even in my own tests), which I have read (and felt) several times, it might not be the best approach.</p><blockquote><p>This article is not focused on any particular technology, since I have found this in a lot of different projects.</p></blockquote><h3>What&#x27;s a unit test</h3><p>According to <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Unit_testing">Wikipedia</a>, unit testing is a &quot;method by which individual units of source code [...] are tested to determine whether they are fit for use&quot;.</p><p>While this might look like a clear definition, it&#x27;s actually quite open because, what&#x27;s a &quot;unit&quot; in the context of unit testing?</p><p>Very often, in object oriented programming projects, people take a class as a unit to test, and create a unit test for every class. In other paradigms, like functional programming, you might consider a function as the unit to be tested, or a set of functions which you have decided to put together in a module.</p><p>This is not really important for the purpose of this article. What&#x27;s really important is to take into account that, in order to properly &quot;unit test&quot; a &quot;unit of source code&quot;, you have to do it by isolating it from any dependency of that unit.</p><p>One of the better ways to achieve this is by following the <strong><a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">Dependency Injection Principle</a></strong>. Without it you will probably end up trying to hack yourself in order to detach a &quot;unit&quot; from its dependencies.</p><blockquote><p>You can find other articles about <a href="/tag/dependency-injection/">Dependency Injection</a> in my blog.</p></blockquote><h3>Replacing dependencies</h3><p>A very frequent practice when unit testing a unit of source code is to replace its dependencies with <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Test_double">test doubles</a>, in order to properly isolate every unit when testing it.</p><p>Test doubles are basically objects compatible with the dependencies of the subject under test, that are created just for the purpose of the test and have some useful capabilities, like capturing how they have been called, or what should they return when called.</p><p>When you use one of those test doubles to assert how they were called as part of the test itself, you are using them as &quot;spies&quot;.</p><h3>Over-trusting spies</h3><p>All this introduction and contextualization had a single purpose.</p><p>I find myself (and others) in the situation in which you prepare a test double to behave in a certain way, then you call your subject under test, and then assert that your expectations on how the test double was called are correct, by spying on it.</p><p>This sometimes feels wrong, since it seems you are testing the test double/s instead of the subject under test.</p><p>I have read many times that, in a unit test, we should not actually know the internal implementation of the subject under test, but only test that, based on certain input, the expected output is returned (so, trust its public API).</p><p>However, there are cases in which some function/method does not really have any output, and we can only verify everything is going right by spying on the test doubles.</p><p>So, at the end of the day, I have mixed feelings about this practice.</p><h3>Conclusion</h3><p>Sadly, I cannot state a clear conclusion. This is actually an open article, and I would love to get your point of view in the form of a <a href="/#comments-box">comment</a>.</p><p>It would be great to see how others face this, if you use other kinds of test doubles instead of spies, or if you are just ok with the implications.</p>

Is spying on mocks a bad practice for unit tests?

<p>I&#x27;ve been wanting to write this article for a while, but it is a subject complex to approach.</p><p>Lately I&#x27;ve had some &quot;conflicts&quot; with users in some of the open source software (OSS) projects I maintain, and I have also seen some of the people I follow on Twitter dealing with the same.</p><p>Because of that I wanted to share my point of view on what should be the attitude and considerations when using OSS.</p><h3>Company vs personal</h3><p>The first thing you have to take into account when using OSS, is that there are two kinds of projects which usually have different goals.</p><h4>Company projects</h4><p>It is very common that companies which activity is related with software or make a deep use of technology, publish their own OSS projects.</p><p>These projects are usually born from some need the company has had which is not strictly part of their domain.</p><p>Thanks to publishing these projects they can find new talent (among contributors), or position themselves in the industry.</p><p>It&#x27;s also quite common that companies provide paid services which are related with these OSS projects, like specific hostings or deployment services, or just consultancy on using them.</p><h4>Personal projects</h4><p>There&#x27;s also projects which are usually maintained by one person, or a very small team, during their own free time.</p><p>These projects are created by people who do it mainly because they love to program and want to share something they have done.</p><p>The goal here is to get some visibility, show some skills, learn something new and contribute to the open source community.</p><p>While the main purpose is not usually getting money, they frequently accept donations and sponsorships.</p><hr/><p>Now we know the two main groups of OSS projects. Sometimes we think they are the same, but company projects are usually maintained by people which is paid by a company, and do it during their working hours.</p><p>On the other hand, personal projects cannot get that much attention and resources, so they cannot progress as fast as the company ones.</p><h3>Considerations</h3><p>That said, when we want to use an open source project or contribute to it, there are a few things to take into account.</p><h4>Always be polite</h4><p>While using a project, you will probably end up finding something is not working as you expected, or you&#x27;ll develop a new need for which the project does not provide a solution.</p><p>When reporting bugs or asking for new features, always try to <strong>be polite</strong>. Provide as many details as possible, be descriptive and help maintainers reproduce the issue.</p><p>If you are asked to do some tests and get back with the result, try to find the time to do it. You may think that&#x27;s not your work, but the issue will get solved much earlier and you will avoid frustrations.</p><p>There&#x27;s a formula I like to use when reporting issues, which consists in filling this template:</p><ul><li>I did <em>[action]</em>.</li><li>I expected <em>[behavior]</em> to happen.</li><li>Instead <em>[other_behavior]</em> happened.</li></ul><p>This will simplify maintainers see the user&#x27;s intention, and detect confusions which are not actually bugs. Helping the user use the tool will be easier this way.</p><h4>Don&#x27;t take anything for granted</h4><p>Just because you open a ticket, does not mean the team is going to work on it right away. There are several reasons that could delay it.</p><ul><li>The project has other priorities.</li><li>It&#x27;s hard to reproduce.</li><li>There&#x27;s no one available to work on it.</li><li>Maintainers just want to spend their time in something else (specially in the case of personal projects).</li></ul><p>The people working in the project is usually dealing with a much wider scope than you might think, so you have to be patient and understand this.</p><p>It could also happen that they don&#x27;t really want to maintain what you proposed, even though it&#x27;s a supper critical feature for you, but a project will never be able to cover the 100% of use cases.</p><h4>Consider contributing</h4><p>One of the main principles of the open source philosophy is collaboration.</p><p>If you have been using an OSS project, the best way to show some appreciation and collaborate with its continuity is by contributing to it.</p><p>There are several ways to contribute.</p><ul><li>You could improve the documentation,</li><li>You could provide some PR fixing some bug or improving the code.</li><li>You could provide some PR with some new feature.</li><li>You could make some economic donation or sponsorship.</li></ul><p>The last one is very rare, specially among individual users, but if your company is taking advantage of an OSS project, you should consider it.</p><p>For the other three cases, if there&#x27;s something you think you can help with, there&#x27;s something to take into account in relation with previous point. You should <strong>always ask first</strong>.</p><p>Maybe someone is already working on something similar, or the team has some ideas in mind that could be shared before starting any implementation, or, as I said before, maybe they just don&#x27;t want to maintain it.</p><p>If you ask first you will save yourself some time and frustrations.</p><h4>Follow the project rules</h4><p>All projects have rules, and I&#x27;m talking about any kind of rule. How to write issues, the code of conduct, the coding standards, the amount of people that need to approve a PR before merging it...</p><p>You have to always follow these rules. Don&#x27;t try to enforce something just because you consider it better.</p><p>If the project requires the use of spaces for indentation but you used tabs because you like them better, don&#x27;t get mad if maintainers don&#x27;t want to merge your PR.</p><h4>Don&#x27;t take it personally</h4><p>And finally, because of the reasons exposed in previous points, there will be decisions you don&#x27;t like.</p><p>Don&#x27;t take it personally, because it&#x27;s not in most of the cases.</p><p>Your issue could be closed because you didn&#x27;t follow the issue template, or because they asked you to check something and you didn&#x27;t give any feedback after some days.</p><p>Understand this can happen, and you can always be polite and open a discussion, but never get mad and accuse the team to be unfair or treat you in the wrong way.</p><h3>Conclusion</h3><p>This article describes a set of rules that should help people using OSS projects and people maintaining them to understand each other, but focusing on the former.</p><p>I will try to write something similar but focusing on how maintainers should behave. We obviously forget some times that there&#x27;s people trusting on us when using the software we write.</p>

Considerations to properly use open source software projects

<p>Some of you know that I work now as a full stack javascript developer, and I have interacted with a few different projects, both in front-end javascript and in nodejs.</p><p>My main concern about javascript has been that, apparently, the community has not adopted one of the practices that, for me, has been the most game changing of all: <strong>Dependency Injection</strong>.</p><blockquote><p>Take into account that this is my relative point of view, from a community which is still quite new to me, so if you find that something I say makes no sense at all, you are more than welcome to <a href="/#comments-box">leave a comment</a>.</p></blockquote><h3>Current state of DI in JS</h3><p>At the moment of writing this article, I have made some research, and my feeling is that only very strict object-oriented projects based on <code>Typescript</code> introduce the concept of Dependency Injection.</p><p>Frameworks like <a target="_blank" rel="noopener noreferrer" href="https://angular.io/"><code>Angular</code></a> and <a target="_blank" rel="noopener noreferrer" href="https://nestjs.com/"><code>NestJS</code></a> include dependency injection containers which allow us solving the dependency injection problem in a more than decent way.</p><p>However, these solutions force us to write a code which feels too coupled with the framework.</p><p>I have also found what seems to be a pretty popular framework-agnostic dependency injection container, <a target="_blank" rel="noopener noreferrer" href="http://inversify.io/"><code>InversifyJS</code></a>, which again, seems to be more <code>Typescript</code> oriented (despite the fact that it says it&#x27;s for plain javascript as well).</p><p>From my point of view, the main problem with this one is that its too complex to get it up and running, which makes people get tired of even trying dependency injection.</p><p>Other than this, I have not seen much adoption in plain javascript projects (maybe more functional than object-oriented), where developers just import or require the dependencies to be used from other modules and use them, which couples the code and makes it really hard to test (at least unit test).</p><h3>Good dependency injection</h3><p>I want to start by trying to define how I feel dependency injection should be done, so that it&#x27;s flexible and useful, and not scary to use:</p><ul><li><p>We should be able to write code in javascript modules in a way we don&#x27;t care where our dependencies come from, or how are they going to be created.</p><p>  I have seen some attempts in which dependencies are imported or required in the code, but then the module exports some way to override the dependency at runtime (with the intention to do it in tests).</p><p>  This is a sort of working approach, but it feels a little bit hacky. It&#x27;s also always importing external code which could have other side effects.</p></li><li><p>We should never be forced to couple our own code with the dependency injection framework. At some point we could want to change the implementation, and that shouldn&#x27;t make us change our code.</p></li><li><p>The dependency injection container (which is the object which encapsulates how dependencies are created and injected into objects, <strong>DIC</strong> from now on), should never leak into our code.</p><p>  It belongs to bootstrapping scripts only. It is also acceptable to get it in code which only purpose is creating objects in the context of dependency injection itself.</p><p>  By importing or requiring the DIC inside modules, we are hiding the module&#x27;s dependencies, and ending up with the ugly service locator anti pattern.</p></li><li><p>Configuring the DIC should always be an easy task. We should be able to just provide simple configuration or simple factories for corner cases in which a basic config is not enough.</p><p>  When the DIC is hard to configure or too feature-bloated, people end up with the feeling that dependency injection is not worth it.</p></li><li><p>The DIC should be able to recursively resolve dependencies. We shouldn&#x27;t need to know what are the dependencies of our dependencies. When creating an object, it should be enough to just pull its direct dependencies from the container, and it should know how to recursively resolve the rest.</p></li></ul><p>With all this in mind, I have created a proof of concept <a target="_blank" rel="noopener noreferrer" href="https://expressjs.com/"><code>express.js</code></a>-based project which makes use of a very simple custom DIC to solve dependency injection.</p><p>You can find the project <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/dependency-injection-container-js">here</a>.</p><h3>Explaining the proof of concept</h3><p>The project is pretty simple. You can just clone it and then run <code>npm install &amp;&amp; node server.js</code>. It will serve the app in <a target="_blank" rel="noopener noreferrer" href="http://localhost:3000">localhost:3000</a>.</p><p>The default path just displays a &quot;Hello World&quot; message, and it has a second <a target="_blank" rel="noopener noreferrer" href="http://localhost:3000/users">/users</a> path which returns a JSON response where some data is dynamically generated. You can refresh the page in order to see it.</p><p>The main characteristic of this project is that, if you open any of the files in <code>controllers</code> or <code>services</code>, you&#x27;ll see they don&#x27;t import or require anything.</p><p>Instead they just expose a builder function (or factory function, or construction function, or whatever you want to name it), which in turn returns the actual object which is going to be used at runtime (remember that, in javascript, functions are first-class objects).</p><p>Let&#x27;s take the <code>listUsersController</code> as an example:</p><pre><pre><code class="language-js">const listUsersController = getUsers =&gt; (req, res, next) =&gt; {
    const users = getUsers();
    res.send(JSON.stringify(users));
};

module.exports = listUsersController;
</code></pre></pre><p>What this module exports is a function where a dependency has to be injected. However, when implementing the controller, we don&#x27;t care where it is going to come from. We just expose the fact that the controller needs that <code>getUsers</code> dependency in order to properly work.</p><p>When that function is called with the dependency, it will return the actual controller (a simple express middleware).</p><p>The only place where actual modules are imported is the <code>config/services.js</code> file, which is a simple map where we basically define which are the dependencies for every object.</p><pre><pre><code class="language-js">const homeControllerFactory = require(&#x27;../controllers/homeController&#x27;);
const listUsersControllerFactory = require(&#x27;../controllers/listUsersController&#x27;);

const utils = require(&#x27;../services/utils&#x27;);
const getUsersFactory = require(&#x27;../services/getUsers&#x27;);

const services = {
    mainController: container =&gt; homeControllerFactory(),
    listUsersController: container =&gt; {
        const getUsers = container.get(&#x27;getUsers&#x27;);
        return listUsersControllerFactory(getUsers);
    },

    utilsService: container =&gt; utils,
    getUsers: container =&gt; {
        const utils = container.get(&#x27;utilsService&#x27;);
        return getUsersFactory(utils);
    }
};

module.exports = services;
</code></pre></pre><p>This file only defines how the builder/creator/factory functions for every object have to be invoked, by first pulling their direct dependencies from the container, if any.</p><p>This file is then imported in the <code>server.js</code> file, which is our entry point. Together with the <code>container/container.js</code> file, they make a super basic dependency injection container.</p><p>Since this DIC is capable of recursively resolving dependencies, our <code>server.js</code> file is the only place where we manually pull objects from the container (the controllers in this case).</p><pre><pre><code class="language-js">const express = require(&#x27;express&#x27;);
const services = require(&#x27;./config/services&#x27;);
const container = require(&#x27;./container/cotainer&#x27;)(services);

const app = express();
const port = 3000;

// We pull the controllers from the container here
app.get(&#x27;/&#x27;, container.get(&#x27;mainController&#x27;));
app.get(&#x27;/users&#x27;, container.get(&#x27;listUsersController&#x27;));

app.listen(port, () =&gt; console.log(`Example app listening on port ${port}!`));
</code></pre></pre><h3>Evolving the proof of concept</h3><p>We have defined a pretty simple approach where we have been able to fulfil all the requirements for a good dependency injection.</p><p>The code is easy to maintain, completely decoupled from the container and from other modules, and registering objects just takes two or three lines of code.</p><p>The main problem is that we are now forced to maintain a too basic DIC which also lacks some basic features, like lazy loading or avoiding the same service to be created more than once.</p><p>In order to solve that, we are going to introduce a project dependency on the <a target="_blank" rel="noopener noreferrer" href="https://github.com/young-steveo/bottlejs"><code>BottleJS</code></a> package, which is a dependency injection <em>micro</em> container.</p><p>Thanks to that package, we can evolve and merge our <code>config/services.js</code> and <code>container/container.js</code> files into a single one which looks like this:</p><pre><pre><code class="language-js">const Bottle = require(&#x27;bottlejs&#x27;);
 
const homeControllerFactory = require(&#x27;../controllers/homeController&#x27;);
const listUsersControllerFactory = require(&#x27;../controllers/listUsersController&#x27;);

const utils = require(&#x27;../services/utils&#x27;);
const getUsersFactory = require(&#x27;../services/getUsers&#x27;);

const bottle = new Bottle();

bottle.constant(&#x27;utilsService&#x27;, utils);
bottle.serviceFactory(&#x27;getUsers&#x27;, getUsersFactory, &#x27;utilsService&#x27;);

bottle.serviceFactory(&#x27;mainController&#x27;, homeControllerFactory);
bottle.serviceFactory(&#x27;listUsersController&#x27;, listUsersControllerFactory, &#x27;getUsers&#x27;);

module.exports = bottle.container;
</code></pre></pre><p>It&#x27;s basically the same, but this time, we just need to pass the list of dependencies for every object by its name to a <code>Bottle</code> instance, and then export the bottle container.</p><p>This container has also a few interesting extra features which might be handy in larger projects.</p><blockquote><p>The amount of stars in this package makes me think that maybe my previous conclusion was wrong, and dependency injection is more extended in javascript projects than I thought.</p></blockquote><p>You can find the whole proof of concept project using <code>BottleJS</code> in the same repository, under the <code>with-bottle</code> branch, <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/dependency-injection-container-js/tree/with-bottle">here</a>.</p><h3>Conclusion</h3><p>My conclusion is that dependency injection in plain javascript and even non object-oriented projects is, not only possible, but desirable.</p><p>Having a really decoupled codebase, where true <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">dependency inversion</a> is achieved thanks to dependency injection, will make our projects much easier to maintain in the long term, and easier to unit test.</p><blockquote><p>I have not covered other scenarios in this article, like front-end application with <a target="_blank" rel="noopener noreferrer" href="https://reactjs.org/">ReactJS</a> or <a target="_blank" rel="noopener noreferrer" href="https://vuejs.org/">VueJS</a>. I will try to do it in the future, when I have become wiser :P</p></blockquote><blockquote><p><strong>Update 2018-12-16:</strong> I have found an article where <a target="_blank" rel="noopener noreferrer" href="https://medium.com/@magnusjt">Magnus Tovslid</a> proposes a very similar approach but for ReactJS and Redux front-end applications. Take a look at it, it&#x27;s very interesting. <a target="_blank" rel="noopener noreferrer" href="https://medium.com/@magnusjt/inversion-of-control-and-di-in-reactjs-and-redux-35161fcef847">Inversion of Control and DI in Reactjs and Redux</a></p></blockquote>