How to reduce duplication in your GitHub Actions workflows

Recently ReactJS v18 was released. I started to look into its improvements, and checked which of my projects could benefit from them.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.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.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.<h3>First fix attempt</h3>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.I checked if there was one for React 18, but sadly there wasn&#x27;t.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.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>.<h3>Migration strategy</h3>I decided to follow a migration strategy similar to the one suggested in the article above, but with a couple of modifications:<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>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.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.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;.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.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.<h3>Benefits I have experienced</h3>Once I started migrating the first tests I noticed some benefits:<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>And overall, it felt good and I have already dedicated a couple of PRs just to migrate more tests.<h3>Challenges I faced</h3>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:<ul><li>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.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.</li><li>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>.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>.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.</li><li>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.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.<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>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.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.Then I used snapshots again to verify they had the expected &quot;shape&quot;.<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>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.If you are using it in bigger projects, following the process described in this article will probably help you.In any case, you will get surprised. React testing library is a great tool and provides many benefits over enzyme.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.

My experience migrating from enzyme to react testing library

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.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.<h3>Generating the code coverage</h3>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.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.However, generating a reliable code coverage report is not always that easy for other types of tests.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.<h3>Remote code coverage</h3>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:<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>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.<h3>Code coverage reports</h3>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.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.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.<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>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:<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>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>.</blockquote>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><img src="/assets/img/remote-coverage/invalid-api-coverage.png" alt="Invalid API coverage"/>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.<h3>Supporting mutation testing</h3>To be more precise with the generated reports, I needed some way to notify the server about the specific test performing the request.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.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).<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>Then, inside your test you can do something like this:<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>After this, the code coverage reports will properly show the actual tests covering them.<img src="/assets/img/remote-coverage/valid-api-coverage.png" alt="Valid API coverage"/><h3>Alternative approach</h3>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>.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.If that works for you, it&#x27;s much more straightforward, and you won&#x27;t need to bother changing your tests bootstrap script.<h3>Conclusion</h3>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.I plan to apply something similar for E2E tests for a command line app, so maybe I extend this article at some point.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.I hope this helped you, and now you can collect code coverage reports on your API tests.

Capturing remote code coverage in API tests with PHPUnit

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.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.In this article I will explain how to set everything up, and what are some considerations and problems you may face during the process.<h3>Enable github pages</h3>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.In order to do that go to your repository and then Settings -&gt; Pages, look for the Source section, and you should see something like this:<img src="/assets/img/preview-envs/github-pages-before-enabling.png" alt="GitHub pages before enabling"/>Click in the dropdown and select your new branch, <code>preview-env</code>. Then click Save.<img src="/assets/img/preview-envs/github-pages-after-enabling.png" alt="GitHub pages after enabling"/>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>.<h3>Configure the workflow</h3>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:Let&#x27;s imagine we have a React web app that is built with node.js. The configuration could look like this.<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>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>.</blockquote>This workflow will follow the next steps:<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>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.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.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.<h3>Considerations when using forks</h3>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).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.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.However, with a couple small config changes, we can work around these limitations:<h4>Change event</h4>The first thing we need to do is use the <code>pull_request_target</code> event instead of the <code>pull_request</code> one.<pre><pre><code class="language-diff">on:
- pull_request: null
+ pull_request_target: null
</code></pre></pre>According to the documentation, this is equivalent to the <code>pull_request</code> event, but it runs in the scope of the base repository.Thanks to this, the <code>GITHUB_TOKEN</code> will come with write permissions, and we will have access to secrets if needed.<h4>Checkout the fork</h4>The second thing we are going to change is that we now need to specify the repository to checkout.In order to do that, we need to add two inputs to the &quot;Checkout code&quot; step, like this:<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>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.And that&#x27;s it. With these two changes you can now deploy preview environments for pull requests coming from forks.<blockquote>IMPORTANT! 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.</blockquote><h3>Other considerations</h3>Other than the limitations for forks, there are a few other minor things to take into consideration.<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

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.Versioning software is not as straightforward as it might look when you don&#x27;t have a lot of experience.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.<h3>Semantic Versioning</h3>The first thing you need is a solid set of rules that help you decide which should your next version be.I remember thinking &quot;is this version big enough as to jump from 1.0 to 2.0?&quot; or &quot;I have seen projects using three numbers for the version, X.Y.Z, should I do the same?&quot;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.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.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:<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>These rules are easier to apply to libraries and frameworks than it is for apps and services. More about this later.</blockquote><h3>Try to keep backwards-compatibility</h3>Ok, we have some rules now. However, I have seen very frequently people mistaking what can be done with what should be done.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.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.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.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.<h3>Provide clear upgrade paths</h3>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.<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>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.The best way to achieve this is to provide clear and simple upgrade paths:<ul><li>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.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.</li><li>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.You can also use some other platform to document the change log, like GitHub releases.</li><li>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.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>.</li></ul><h3>Versioning libraries vs apps</h3>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.For example, how do you identify a backward compatibility break on a web user interface?With this kind of software there are more grey areas, and you will end up using your intuition.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.Because of this there are projects that use different approaches to version apps. For example:<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>There&#x27;s also a set of special versions that can be used to publish the so-called pre-release 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.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.<h4>0.x.y</h4>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.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>.<h4>Alpha</h4>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 productionAlpha versions are on their very early stages. Their public API is very likely to change, and they probably contain bugs.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>.<h4>Beta</h4>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.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>.<h4>Release candidate</h4>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.They should not contain many bugs, but some could be found. The public API should not change anymore.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>.<h3>Conclusion</h3>We have seen some approaches and considerations to properly version your software.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.With those tools, you will be able to properly version your software.

What to take into account when versioning software

Let&#x27;s not deny that <a target="_blank" rel="noopener noreferrer" href="https://github.com/features/actions">GitHub actions</a> are hitting hard in the tech community, and many projects are transitioning from other continuous integration systems like <a target="_blank" rel="noopener noreferrer" href="https://circleci.com/">Circle CI</a> or <a target="_blank" rel="noopener noreferrer" href="https://travis-ci.org/">Travis CI</a>.Personally I have been using Travis a lot during the past years, for all my OSS projects, and I have gotten very used to it.However, people seem to be &quot;abandoning&quot; travis in favor of GitHub Actions, for different reasons. &quot;It&#x27;s faster&quot;, &quot;I can run smaller tasks in parallel&quot;, etc.In my case, I have moved a few very specific tasks there, where travis was becoming a bottleneck, but I still have mixed feelings about the very-verbose yaml-based config needed to configure a few GitHub Actions, compared to the more concise travis one.In this article I&#x27;ll explain how I improved a travis build to run several smaller tasks in parallel jobs, without having to completely move away from it.<h3>Initial state</h3>This project&#x27;s travis config is relatively simple. It is used to build a JS project for the web browser, and it has to run the next tasks:<ul><li>Lint the code, to make sure it fulfils the project&#x27;s coding standards.</li><li>Run unit tests.</li><li>Run mutation tests.</li><li>Build the docker image, to make sure none of the new changes broke it.</li><li>Conditionally publish a release on GitHub, with a dist file attached to it, if the build is being run for a git tag.</li></ul><pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
 only:
 - /.*/

cache:
 directories:
 - node_modules

services:
 - docker

node_js:
 - &#x27;12.16.3&#x27;

install: npm ci

before_script:
 - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
 - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)

script:
 - npm run lint
 - npm run test:ci
 - npm run mutate:ci
 - docker build -t project:test .

after_success:
 - node_modules/.bin/ocular coverage/clover.xml

before_deploy: npm run build ${TRAVIS_TAG#?}

deploy:
 - provider: releases
 api_key:
 secure: &lt;key&gt;
 file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
 skip_cleanup: true
 on:
 tags: true
</code></pre></pre><h3>Problems with this approach</h3>This is more or less ok, but the last two commands in <code>script</code> can be relatively slow and can delay the whole process.Also, specially the mutation tests one, which is currently always considered successful regardless the result, can make the build reach the maximum run time allowed by travis, making the whole build falsely fail.<blockquote>The reason for the <code>before_script</code> step is to determine which source code files changed, and run mutation tests on them only, in order to mitigate this.</blockquote>Other than this, the build config defines &quot;global&quot; customizations that are actually only used for some tasks:<ul><li>Running <code>npm ci</code> is not required for the <code>docker build</code> task.</li><li>Getting the <code>docker</code> service is not required by any of the other tasks.</li><li>Determining changed files is only used by the <code>mutation tests</code> task.</li></ul><h3>Making use of jobs</h3>One cool feature travis supports is the use of a job <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/build-matrix/">build matrix</a>, that lets you define multiple jobs that run in parallel as part of the same build, and make each one of them do unrelated tasks.Using this feature it is possible to improve the <code>.travis.yml</code> file, making it look like this:<pre><pre><code class="language-yaml">dist: bionic

language: node_js

branches:
 only:
 - /.*/

cache:
 directories:
 - node_modules

node_js:
 - &#x27;12.16.3&#x27;

jobs:
 fast_finish: true
 allow_failures:
 - name: &#x27;Mutation tests&#x27;
 include:

 - name: &#x27;Lint&#x27;
 install: npm ci
 script: npm run lint

 - name: &#x27;Unit tests&#x27;
 install: npm ci
 script: npm run test:ci
 after_success:
 - node_modules/.bin/ocular coverage/clover.xml

 - name: &#x27;Mutation tests&#x27;
 install: npm ci
 before_script:
 - echo &quot;Building commit range ${TRAVIS_COMMIT_RANGE}&quot;
 - export MUTATION_FILES=$(git diff ${TRAVIS_COMMIT_RANGE:-origin/main} --name-only | grep -E &#x27;src\/(.*).(ts|tsx)$&#x27; | paste -sd &quot;,&quot;)
 script: npm run mutate:ci

 - name: &#x27;Build docker image&#x27;
 services:
 - docker
 install: skip
 script: docker build -t project:test .

 - name: &#x27;Publish release&#x27;
 if: tag IS present
 install: skip
 script: skip
 before_deploy: npm run build ${TRAVIS_TAG#?}
 deploy:
 - provider: releases
 api_key:
 secure: &lt;key&gt;
 file: &quot;./dist/project_${TRAVIS_TAG#?}_dist.zip&quot;
 skip_cleanup: true
 on:
 tags: true
</code></pre></pre>This approach introduces all these benefits:<ul><li>Now linting, testing, mutation testing and building the docker image run in parallel, making the build finish earlier.</li><li>The mutation testing step is allowed to fail, and thanks to the <code>fast_finish</code> flag, travis won&#x27;t even wait for it to finish, considering the build successful once the rest have passed.</li><li>Configs that are only meaningful for certain jobs are defined in the job itself, instead of globally.</li><li>The &quot;publish release&quot; job only runs conditionally if the build is for a tag, thanks to the <code>if: tag IS present</code> condition. (More info about <a target="_blank" rel="noopener noreferrer" href="https://docs.travis-ci.com/user/conditional-builds-stages-jobs/">conditional jobs</a> in travis).</li><li>As soon as any of the jobs fails, the whole build fails and you don&#x27;t have to continue waiting. Before this, if the third task failed, you still had to wait for the previous two to finish.</li><li>Each job can have a name, making it more clear in travis UI what tasks are being run:</li></ul><img src="/assets/img/travis-multiple-jobs/travis-jobs.png" alt="Travis CI jobs"/><h3>Conclusion</h3>The main purpose of this article was to showcase that travis still has a lot to give. Github Actions are definitely cool, but there&#x27;s usually no silver bullet for everything, and a combination with other tools might be more suitable.Also, this allows people using travis to improve their builds without having to change everything. Then, once you have split your tasks, if you still want to move to Github Actions, it should be easier.<blockquote>If you are curious, this is the project in which I use this travis configuration: <a target="_blank" rel="noopener noreferrer" href="https://github.com/shlinkio/shlink-web-client">shlinkio/shlink-web-client</a>.</blockquote>

Running several steps of a Travis CI build in parallel

For a long time, I have been trying to include tests in every project in which I&#x27;ve worked on.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.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.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.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.<blockquote>This article is not focused on any particular technology, since I have found this in a lot of different projects.</blockquote><h3>What&#x27;s a unit test</h3>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;.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?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.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.One of the better ways to achieve this is by following the <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Dependency_inversion_principle">Dependency Injection Principle</a>. Without it you will probably end up trying to hack yourself in order to detach a &quot;unit&quot; from its dependencies.<blockquote>You can find other articles about <a href="/tag/dependency-injection/">Dependency Injection</a> in my blog.</blockquote><h3>Replacing dependencies</h3>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.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.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;.<h3>Over-trusting spies</h3>All this introduction and contextualization had a single purpose.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.This sometimes feels wrong, since it seems you are testing the test double/s instead of the subject under test.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).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.So, at the end of the day, I have mixed feelings about this practice.<h3>Conclusion</h3>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>.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.

Is spying on mocks a bad practice for unit tests?

There&#x27;s no doubt that having tests in a project allows you to find potential bugs earlier and more easily.Lots of OSS projects require a minimum code coverage in order to accept new pull requests from contributors, and proprietary projects also tend to have some sort of continuous integration workflow which requires certain metrics to be fulfilled in order to get builds passing.However, the code coverage can lead to a false sense of security, which makes you think that if certain class has a 100% code coverage, it is also 100% bug-free.This is not always true, since you could be calling a method and yet not being properly testing its output or its real behavior. The code coverage will mark it as covered, but you might introduce a bug and still have a green test.This is where mutation testing comes in.<h3>Mutation testing</h3>According to <a target="_blank" rel="noopener noreferrer" href="https://en.wikipedia.org/wiki/Mutation_testing">wikipedia</a>, mutation testing involves applying small modifications to a software. These modifications are called mutations.Then, if you pass your tests and any of them fails because of this &quot;mutation&quot;, then you have &quot;killed the mutant&quot;. This is what should happen in code which is covered by tests. If tests keep passing after applying this modification, then your tests covering that part of the project are not so good, and you should improve them to really test what they are covering.So in other words, mutation testing is a quality assurance practice for your tests.In PHP projects, there used to be one library which purpose was working with the mutation testing approach, <a target="_blank" rel="noopener noreferrer" href="https://github.com/humbug/humbug">humbug/humbug</a>. However, it is mostly abandoned now, and it has motivated the appearance of another project, <a target="_blank" rel="noopener noreferrer" href="https://infection.github.io/">infection/infection</a>.<h3>Infection</h3>Infection is a mutation testing framework for PHP.It is easy to start using it in your project, since you just need to install it (<code>composer require infection/infection --dev</code>), and create a configuration file. Then, it uses your existing test suite in order to apply mutations to your code and check your tests.It currently integrates with <a target="_blank" rel="noopener noreferrer" href="https://github.com/sebastianbergmann/phpunit/">phpunit</a> and <a target="_blank" rel="noopener noreferrer" href="https://github.com/phpspec/phpspec">phpspec</a>, but I suppose there will be compatibility with other testing frameworks in the future.<h4>Configuring infection</h4>It consumes an <code>infection.json</code> configuration file which could have a structure like this:<pre><pre><code class="language-json">{
 &quot;source&quot;: {
 &quot;directories&quot;: [
 &quot;module/*/src&quot;
 ]
 },
 &quot;timeout&quot;: 10,
 &quot;logs&quot;: {
 &quot;text&quot;: &quot;build/infection/infection-log.txt&quot;,
 &quot;summary&quot;: &quot;build/infection/summary-log.txt&quot;,
 &quot;debug&quot;: &quot;build/infection/debug-log.txt&quot;
 },
 &quot;tmpDir&quot;: &quot;build/infection/temp&quot;,
 &quot;phpUnit&quot;: {
 &quot;configDir&quot;: &quot;.&quot;
 }
}
</code></pre></pre>This is the configuration of one of my company&#x27;s projects. A modular application where every module is located inside the <code>module</code> directory and has its own <code>src</code> folder with source files.This config file basically defines where the sources are located, where infection&#x27;s logs should be placed, a temporary folder which will be used instead of using system&#x27;s default tmp folder, and where is the <code>phpunit.xml[.dist]</code> file.That&#x27;s all you need to get infection working.<blockquote>You can find detailed information of all the configuration options <a target="_blank" rel="noopener noreferrer" href="https://infection.github.io/guide/usage.html#Configuration">here</a></blockquote><h4>Running infection</h4>Now that we have the configuration file, we just need to run <code>vendor/bin/infection</code>, and it will execute our test suite and then apply mutations to our source files.Then it will display the result, telling how many mutants have been killed.Infection supports lots of mutators, like replacing <code>++</code> by <code>--</code>, <code>true</code> by <code>false</code>, changing method visibilities, return values, etc. You can find the whole list <a target="_blank" rel="noopener noreferrer" href="https://infection.github.io/guide/mutators.html">here</a>.The command line tool supports a list of modifiers, some of which are very interesting. This is how I would recommend you to run it if you want to address the whole project.<code>vendor/bin/infection --threads=4 --min-msi=70 --only-covered --log-verbosity=2</code>.<ul><li><code>--threads</code>: It runs tests and mutators in parallel processes, so you can take advantage of all the cores in your machine. Set a value that makes sense your you. If you have 8 cores, maybe you want to set it with value 8.</li><li><code>--min-msi</code>: This flag makes the process fail if the number of killed mutants is below certain percentage. In this case we require 70% of mutants to be killed. Adapt the value to your needs, and try to gradually improve your tests and increase this value (MSI stands for Mutation Score Indicator). This flag is really useful in continuous integration environments.</li><li><code>--only-covered</code>: This makes infection address only covered code. We know mutants won&#x27;t be killed in uncovered code, so I think it makes no sense to apply mutators there. I prefer to separate the required code coverage metric from the required mutation score indicator metric.</li><li><code>--log-verbosity</code>: By default, infection logs all the mutations it has applied to your code. This could lead to a log with thousands of lines if the project is big, so I prefer to set the log verbosity to 2, which makes it log only non-killed mutants.</li></ul>And that&#x27;s mainly it. You can now automate this task in your continuous integration pipeline, or just run it locally, but at least you will discover some parts both in your source files and your tests that can be improved.<h3>Troubleshooting</h3>While this could be enough for an introduction to infection, the title of this article says something about big projects, so I&#x27;m going to explain how we integrated infection in one of my company&#x27;s biggest projects and how we addressed some inherent problems.<h4>Already unstable</h4>The first problem while working with infection is that, at the moment of writing this article, it&#x27;s not in a stable version yet. That means you could find bugs.We found one in which infection wasn&#x27;t properly parsing our phpunit config file and it was excluding almost the whole project from the code coverage report. This caused all mutations to be skipped.We reported it and they fixed it very fast, but they haven&#x27;t tagged a version including the fix yet, so we require one specific commit from master while we wait for v0.8 to be released.<h4>Time consuming</h4>Another problem is that infection consumes a lot of memory and CPU, and takes a lot of time to be run when you have a lot of classes and tests.For example, our project has around 1500 unit tests, which take about 1&#x27;5min-2min to be run. Our build process also passes some coding style checks and functional repository tests. It usually takes about 3 minutes.The first time we run infection for the whole project, it took more than 16 minutes. That would make a build which is taking 3 minutes to take almost 20 minutes from now on, which is not an option because our build is run a lot of times every day.Our solution was making the build run infection only on changed sources, taking advantage of infection&#x27;s <code>--filter</code> flag, which lets you pass a comma-separated list of files and it gets applied only to them.The way in which we find which files have changed from previous build is by making a <code>git diff</code> between a commit from previous successful build and the new commit after updating the branch in which the build is being run (the commit identifiers are defined by jenkins&#x27; GIT plugin as environment variables).If it is the first time the build is run for this branch, we make the diff with <code>origin/develop</code> instead.The result is a bash script like this:<pre><pre><code class="language-bash"># Get files which have changed from latest processed commit, including only those inside sources
# If there&#x27;s no previous commit, diff with develop
INFECTION_FILTER=$(git diff ${GIT_PREVIOUS_SUCCESSFUL_COMMIT:-origin/develop} $GIT_COMMIT --name-only | grep /src/ | paste -sd &quot;,&quot; -)

# Check mutations over those files, if any, and require a 70% MSI
if [ -n &quot;$INFECTION_FILTER&quot; ]; then
 vendor/bin/infection --threads=4 --min-msi=70 --only-covered --log-verbosity=2 --filter=&quot;${INFECTION_FILTER}&quot;
else
 echo &quot;No source files affected. Infection skipped.&quot;
fi
</code></pre></pre>As you can see, we perform a diff by including only file names, then we exclude those which do not contain &quot;/src/&quot; as part of the name, and then we convert them into a comma-separated list.With this approach, the build usually takes 1 extra minute in the worst case scenario, which can be assumed.However, I&#x27;m sure the performance of this project will be improved as it grows and gets more stable.<h4>Test run duplication</h4>While previous approach filters the files where mutations are applied, it is still running all tests beforehand, which makes all tests to be run twice on every build.<ul><li>First, our own execution, which generates a code coverage report to be published later, and makes the build fail if tests do not pass.</li><li>Then, infection runs tests again, on its own &quot;conditions&quot; (they take your phpunit config file and generate a new one, which has some custom configuration entries).</li></ul><strike>If it were possible to pass infection an already generated code coverage, we could prevent this duplication, but, as far as I know, it does not support that.</strike> **It does now**.Another solution would be being able to run only tests which affect changed sources, instead of running all tests suites, but phpunit does not allow to filter by a list of files, only a specific file or folder.<strike>This is the only problem for which we have not yet found a solution, so If you know any workaround, a comment will be very welcome :-)</strike>Update 2018-02-22Following what Maks suggested in this <a href="/#comment-3762900802">comment</a>, we have changed the process a little bit, and using a more recent commit from <code>dev-master</code>, we can take advantage of a feature which allows an existing code coverage to be passed to infection.Now, our phpunit execution includes these two flags: <code>--coverage-xml=build/coverage-xml --log-junit=build/phpunit.junit.xml</code>And then, infection is executed with <code>--coverage=build</code>.That&#x27;s it, no need to run tests twice anymore :-)<h4>Xdebug vs phpdbg</h4>Since infection needs access to a code coverage report, you need some tool which is capable of generating it.People usually use xdebug, since it is the most extended and feature-rich debugging tool.However, there&#x27;s a simpler tool, which is designed to debug php console executions only, and comes bundled with php. It is <a target="_blank" rel="noopener noreferrer" href="https://github.com/krakjoe/phpdbg">phpdbg</a>.In our project, it usually takes 30%-50% less time to generate a code coverage report than xdebug. The result is not 100% the same, but it is very similar, and it&#x27;s worth it.So, instead of running infection like this:<pre><pre><code>vendor/bin/infection --threads=4 --min-msi=70 --only-covered --log-verbosity=2 --filter=&quot;${INFECTION_FILTER}&quot;
</code></pre></pre>We have to do it like this<pre><pre><code>phpdbg -qrr vendor/bin/infection --threads=4 --min-msi=70 --only-covered --log-verbosity=2 --filter=&quot;${INFECTION_FILTER}&quot;
</code></pre></pre>It is explained in <a target="_blank" rel="noopener noreferrer" href="https://infection.github.io/guide/usage.html#Running-with-phpdbg">infection&#x27;s docs</a>.We have even started to use it to run our own phpunit execution.<h3>Conclusion</h3>We have seen how to use infection, and how to integrate it in a continuous integration pipeline, even for big projects.I think it is a very useful tool, and the team behind it is doing a great job. It is also not hard to start using it, since you don&#x27;t really need to write new code, just add a config file and run the CLI tool.Finally, I recommend you to read this article, from infection&#x27;s author. It explains how it internally works, and how to use it in a development workflow <a target="_blank" rel="noopener noreferrer" href="https://medium.com/@maks_rafalko/infection-mutation-testing-framework-c9ccf02eefd1">https://medium.com/@maks_rafalko/infection-mutation-testing-framework-c9ccf02eefd1</a>.

Mutation testing with infection in big PHP projects

At some point, any enterprise project will probably need a message queue.A message queue is used to publish information (usually known as messages) that a different &quot;node&quot; (usually known as worker) will consume in order to perform a specific action.It is frequently used in web applications to pass information to background workers that consume the queue and perform long tasks, but it is also an important part when applying concepts like <a target="_blank" rel="noopener noreferrer" href="https://martinfowler.com/eaaDev/EventSourcing.html">Event Sourcing</a> to your architecture.It is also really important when working with microservices, since it is a way to enable data exchange between each service.Whatever the case, it is very likely that you will eventually need to decide which message queue to use.<h3>Why AWS Simple Queue Service</h3>In my company we had to decide this some time ago.We started testing different services, seeing what their strengths and weaknesses were.If I remember correctly, we tested <a target="_blank" rel="noopener noreferrer" href="https://www.rabbitmq.com/">RabbitMQ</a>, <a target="_blank" rel="noopener noreferrer" href="https://kr.github.io/beanstalkd/">Beanstalkd</a>, <a target="_blank" rel="noopener noreferrer" href="https://redis.io/">Redis</a> and <a target="_blank" rel="noopener noreferrer" href="https://aws.amazon.com/sqs/">AWS Simple Queue Service</a> (SQS from now on).The conclusion was that RabbitMQ is the one with the more features, by far. However, it is also the most complicated to configure and interact with.Also, we would have to maintain the RabbitMQ clusters ourselves (the same happens with Beanstalkd).Since we work with AWS, we decided to give SQS a try, and its simplicity convinced us.It is super simple to create a new queue, and using one of their SDKs, you can interact with it in minutes.Also, the price is absurdly cheap. It is virtually free for &quot;small&quot; amounts of requests (and when I say small, I mean that performing 1 request to their API every 20 seconds during 1 year costs about $0.30 at the end of the year).It is by far cheaper than maintaining your own instances with a different service, and I&#x27;m not counting the cost in time you will have to invest in maintaining those servers.<h3>The &quot;small&quot; problem with SQS</h3>One of the most interesting features with RabbitMQ is that you can open one socket with the queue server, and once a new message gets in, the worker is &quot;notified&quot; and the message can be consumed. This way, you have a process which is always running, listening for a queue, and processing messages as soon as possible.This is usually the desired behavior. You don&#x27;t want any delay on processing messages (or the delay should be as short as possible).On the other hand, SQS bills by API request. This means that the worker has to manually check if there&#x27;s any message in the queue, in small intervals.Our first approach was configuring cron jobs in our workers, so that they could check if there were any message in the queue, and process all of them, if any.This was problematic, since it applies a delay of up to one minute (you can&#x27;t configure a cron to be run with an interval smaller than that), which is not desirable, particularly when the job takes 5-10 seconds to complete. Adding an extra 600% of waiting time can affect the user experience, or have other side effects, depending on the task.<h3>The long polling to the rescue</h3>The first solution that came to our mind was making the workers run requests on an infinite loop, but that&#x27;s not a very clean approach, and will result in our workers being at a 100% of CPU usage all the time.We started investigating and found out about a feature in SQS called <a target="_blank" rel="noopener noreferrer" href="https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-long-polling.html">long polling</a>. It lets you tell the queue to wait up to 20 seconds before returning a response, if the message queue is empty, and if during that time a new message enters the queue, return a response immediately.Using it, you can make a worker continuously perform requests at 20 second intervals, but if a message is in the queue, the response will be returned immediately.The final behavior is very similar to a socket, in which you can process a message as soon as it enters the queue, and the worker does not consume any resource while it is waiting for a response.<h3>Configure a queue with long polling</h3>There are two ways of configuring the long polling. You can do it in AWS, and make the queue always have it, or you can do it client-side, and add a <code>WaitTimeSeconds</code> param with the time in seconds (with a maximum value of 20 seconds).The second option is very easy to implement when using any of the official SDKs, and is more flexible, since you can decide when to wait for a message and when to fail immediately when the queue is empty.The first one is very easy too. Just set a value for the &quot;Receive Message Wait Time&quot; param, when configuring the queue.<img src="/assets/img/sqs-socket/receive-message-wait-time.png" alt="SQS Receive Message Wait Time"/>That should be all, but there&#x27;s one important consideration.If you have several workers consuming the same queue with long polling and one message enters the queue, all the workers will receive it until one of them deletes it. This is usually problematic, since it could lead to one task being processed more than once.In order to prevent this, you should set a small value in the &quot;Default Visibility Timeout&quot; param, which tells SQS to deliver the message just to one consumer, and wait that amount of time before delivering it to the rest.This way, you can make one of the workers receive the message, delete it from the queue, and then process it, and that will prevent other workers from receiving it.Usually, setting a value of 3-5 seconds should be more than enough for the first worker to remove it from the queue. However, if you expect your workers to need a longer time, just increase the value.Remember, that value will delay delivering the message to all the workers but the first that gets it.<h3>Conclusion</h3>We have seen an efficient way of working with SQS, the most simple, yet powerful message queue.If you have more complex needs, it might end being too simple, but if not, it is possible to tweak it enough to use it on large applications and services.

How to simulate a socket connection with AWS Simple Queue Service

Earlier last week I found a <a target="_blank" rel="noopener noreferrer" href="https://github.com/WyriHaximus/awesome-phpstorm">github repository</a> which collects different resources related with PhpStorm. Plugins, themes, utilities...I found it very interesting, because I think <a target="_blank" rel="noopener noreferrer" href="https://www.jetbrains.com/phpstorm/">PhpStorm</a> is the best PHP IDE by far, and I&#x27;ve been using it on an almost daily basis for the last 4 years.The thing is that finding that repository gave me the idea of writing a post explaining the list of third party plugins I use and why, in case somebody is starting to use the IDE and wants some ideas on where to start.If you want to get any of them, just search for it inside PhpStorm. It&#x27;s the easiest way to install them.<h3>.env</h3>If you work with env files in your development process, either with <a target="_blank" rel="noopener noreferrer" href="https://github.com/vlucas/phpdotenv">vlucas/phpdotenv</a> (which comes bundled with laravel) or with <a target="_blank" rel="noopener noreferrer" href="https://symfony.com/doc/current/components/dotenv.html">symfony/dotenv</a>, this extension is very handy.It autocompletes environment variables defined in the .env file and the docker-compose.yml file when using the <code>env()</code> or <code>getenv()</code> functions.It also displays the value defined for those env variables inside the file.<img src="/assets/img/phpstorm-plugins/dot-env.png" alt=".env"/><blockquote>As a tip I will say that the first time I installed this plugin it didn&#x27;t work for me, because I had the .env files associated with the ini file type. Make sure you associate them with the .env type instead to get it working.</blockquote>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/9525--env-files-support">https://plugins.jetbrains.com/plugin/9525--env-files-support</a><h3>.ignore</h3>This plugin detects ignored files for many types of resources. Git, docker, npm and many more.It adds syntax highlight and autocompletion to those files (.gitignore, .hgignore...), displaying which of the ignored files do not exist anymore.It also sets a light grey font color in the project explorer for ignored files, so it is easier to &quot;ignore&quot; them.Finally, it displays a message at the top of the editor when you have opened an ignored file, so that you know it is not going to affect the corresponding tool.Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/7495--ignore">https://plugins.jetbrains.com/plugin/7495--ignore</a><h3>BashSupport</h3>If you have to work with shell scripts in any of your projects, this plugin is very useful.It adds syntax highlight, autocompletion, quickfixes and refactoring for <code>bash</code> and <code>sh</code>.It also allows you to add a missing shebang or even run the script right inside PhpStorm by right-clicking and selecting &quot;Run&quot;.<img src="/assets/img/phpstorm-plugins/bash-support.png" alt="BashSupport"/>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/4230-bashsupport">https://plugins.jetbrains.com/plugin/4230-bashsupport</a><h3>CodeGlance</h3>This one os more cool than useful.It adds a minimap inside any file editor, similar to the one that was made popular by Sublime text.It can be used to get an idea of the size of the file just at a glance.<img src="/assets/img/phpstorm-plugins/code-glance.png" alt="CodeGlance"/>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/7275-codeglance">https://plugins.jetbrains.com/plugin/7275-codeglance</a><h3>PHP Annotations</h3>This one is essential if you work with annotations of any kind (doctrine ORM, jms serializer, and such).Since PHP does not natively support annotations, everybody that needs that feature uses the package <a target="_blank" rel="noopener noreferrer" href="https://github.com/doctrine/annotations">doctrine/annotations</a>.It works really great, but since it works at comment level, it is very easy to break something by accident.This plugin adds a lot of features:<ul><li>Mark use statements as used when imported for an annotation.</li><li>Refactor or jump to annotation classes.</li><li>Annotation properties autocompletion (and even values, for well known projects like doctrine/orm).</li><li>Auto alias imports.</li><li>Syntax highlight and error management.</li></ul>This plugin almost suppresses the possibilities of breaking your code when running an automated use statements optimization or remove part of the annotation by mistake, things that cannot be caught by a unit test.<img src="/assets/img/phpstorm-plugins/annotations.png" alt="PHP Annotations"/>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/7320-php-annotations">https://plugins.jetbrains.com/plugin/7320-php-annotations</a><h3>PHP composer.json support</h3>Everybody uses composer for modern PHP projects, so this plugin is a must.It autocompletes composer.json blocks, and validates it, but making sure to never suggest a block that&#x27;s already in the file.It also displays warnings for common mistakes, like using the dev-master constraint for a dependency.It is very useful when you don&#x27;t remember the name of a package, since it autocompletes package names too.<img src="/assets/img/phpstorm-plugins/composer.png" alt="PHP composer.json support"/>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/7631-php-composer-json-support">https://plugins.jetbrains.com/plugin/7631-php-composer-json-support</a><h3>Php Inspections (EA Extended)</h3>If I had to uninstall all my plugins but one, this would be the one that I would keep for sure. Probably the best plugin and the one I use the most on any project.It adds a huge amount of new inspections to PhpStorm that will greatly improve your code.To name some:<ul><li>Warn about non-annotated thrown exceptions.</li><li>Warn about known PHP security issues.</li><li>Suggest better or more readable language constructions.</li><li>Suggest about more efficient ways of perform known tasks.</li><li>Warn about ugly code smells.</li><li>Warn about suspicious code blocks.</li></ul>And things like that. It is impossible to list all the things this plugin is able to inspect. I recommend you to install it and test it, because it really improves your productivity.Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/7622-php-inspections-ea-extended-">https://plugins.jetbrains.com/plugin/7622-php-inspections-ea-extended-</a><h3>PHPUnit Enhancement</h3>I discovered this plugin in the list I mentioned at the beginning of this article, so I have been using it for a short time.I still have to tweak it to fit my needs, but it is better than anything anyway.It mainly tells PhpStorm the type of mocked objects (either by PHPUnit&#x27;s mocks or by PHPSpec&#x27;s prophecies). This way, when you try to mock a method, you get autocompletion, and also, If later on you want to refactor that method or find their usages, it will find the mock too.The problem is that, for example, you might create a prophecy of a method that expects more than one argument or has a specific type hint, and you pass it something like <code>Argument::cetera()</code>. That makes it mark an error because the method expects something else.Apart from that, I think it&#x27;s worth it.Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/9674-phpunit-enhancement">https://plugins.jetbrains.com/plugin/9674-phpunit-enhancement</a><h3>Swagger plugin</h3>When you work on an API that needs to be documented, swagger is a really good tool.This plugin adds autocompletion and inspections on swagger docs, either yaml or JSON, so that you don&#x27;t need to wait for external tools to validate your files.<img src="/assets/img/phpstorm-plugins/swagger.png" alt="Swagger plugin"/>Link: <a target="_blank" rel="noopener noreferrer" href="https://plugins.jetbrains.com/plugin/8347-swagger-plugin">https://plugins.jetbrains.com/plugin/8347-swagger-plugin</a><h3>Conclusion</h3>That&#x27;s all the third party plugins I use at the moment of writing this article.If in the future I add any other, I&#x27;ll update this list.If you know of any cool plugin that&#x27;s not listed here, just add a comment to the article so that other can be aware of its existence.

The PhpStorm plugins of my choice

In a project I&#x27;m working on, we recently needed to add some kind of encryption system that allowed us to store sensitive information in a secure manner, but being able to access to it at runtime in order to pass it to third party services.Securely storing your own app passwords is easy. You just hash it, and the password can be verified without having to decrypt it, but if you need to &quot;decrypt&quot; it, the solution is not that easy.We started by building our own solution based on <a target="_blank" rel="noopener noreferrer" href="https://docs.zendframework.com/zend-crypt/">zend/crypt</a>, which is an excellent solution and works like a charm, but you still need to store the master key somehow, and that&#x27;s the big problem.After some research, someone pointed us to <a target="_blank" rel="noopener noreferrer" href="https://www.vaultproject.io/">vault project</a>, a self-hosted service which manages encrypted key-value pairs, in a more secure manner, where the master key is securely handled. I recommend you read the docs in order to see all its features.Vault supports different storage backends, each one with its own pros and cons. Some are meant to be used in development environments (like in memory and local file) and others are more suitable for production, with support for high availability (like DynamoDB or <a target="_blank" rel="noopener noreferrer" href="https://www.consul.io/">consul</a>, another hashicorp&#x27;s service).The official documentation indirectly recommends using vault with consul, which is a service with more features than just storing data. Indeed, it is a service discovery tool widely used this days in container-based infrastructures.For this reason, we started using both vault and consul in development, in order to get used to both services, but in the end we found it problematic because of different reasons:<ul><li>The consul server needs to get started before vault, otherwise vault fails on start-up. We saw this problem happening in development very frequently, which was annoying.</li><li>We talked with an expert sysadmin that was using consul in production environments. He told us it was a magnificent service, but he warn us about the possibility of having random data loss for no apparent reason. 
When using consul as a service discovery tool, that is not a big problem. Just recreating the consul cluster, all the data is retrieved again from running services. In our case it isn&#x27;t that simple. We were going to store sensitive and important data in consul, and loosing it could be a big problem.</li><li>I usually prefer to maintain as less services as possible in production. I see it from the point of view of a developer. If there is a cloud service that does the job, I prefer to use it rather than maintaining my own server. Be serverless as much as possible.</li></ul><h3>Finding an alternative</h3>Ok, consul is discarded. We need another storage alternative.Looking at vault&#x27;s documentation we saw there are a couple <a target="_blank" rel="noopener noreferrer" href="https://www.vaultproject.io/docs/configuration/storage/dynamodb.html">storage backends</a> that support high availability.We finally decided to go with <a target="_blank" rel="noopener noreferrer" href="https://aws.amazon.com/dynamodb/">AWS DynamoDB</a>. It is much less prone to data loss due to redundant storage under it, easier to buck-up and restore, and much cheaper than having dedicated servers. Also, the project&#x27;s infrastructure is already in AWS, so communication should be fast.Using DynamoDB we now only need to manage vault servers.<h3>Vault&#x27;s high availability</h3>Another of the vault&#x27;s feature is the possibility to configure several servers in high availability mode, as long as the storage supports it.This was a must for us, since getting vault down would make the service to not properly work and produce inconsistent data.The way vault manages high availability is very interesting. The first server that&#x27;s unsealed is set as active, and the rest are set in standby.If a request is performed to one of the servers in standby, they just redirect the request to the active server.If the active server is down, then one of the standby servers takes the leadership and is set as active.The communication between servers does not happen via network communication, but on the shared storage. The active server creates a lock file, and this way, the rest of the servers know they have to standby.This makes every server to work in an independent manner, and makes it easy to add more servers to the cluster if needed.The only problem is how do I make my app dynamically read from the active server, but be able to read from others if the active is down.Do I have to manually manage the load balancing? Do I have to implement some kind of strategy that tries to communicate to each server until one returns a response? That&#x27;s odd.Vault&#x27;s documentation recommends using another consul&#x27;s feature to solve this problem, some kind of DNS that makes a cluster name to resolve to the active instances IP address. This way you just need to perform requests to the cluster name.That&#x27;s good, but we weren&#x27;t going to use consul, right?<h3>AWS internal load balancer to the rescue</h3>After some investigation we saw contradictory opinions on behalf of hashicorp about using a load balancer with vault. Sometimes they recommend not to use it, sometimes they say they are not against nor in favor. Because of the way high availability works in vault, if the balancer redirects to a standby instance and it redirects to the balancer again, you could enter an infinite redirection loop.But what if you could make the load balancer consider standby instances out of service?Gladly, vault&#x27;s API has an <a target="_blank" rel="noopener noreferrer" href="https://www.vaultproject.io/api/system/health.html">endpoint</a> that performs a health check returning a status 200 only on unsealed active instances. If the instance is not active, it returns a 429 status. This endpoint doesn&#x27;t require authentication.Using this endpoint for the balancer&#x27;s health check, the balancer will never redirect to a standby instance.Also, if the active instance has any problem and goes down, as soon as a standby instance takes leadership, the load balancer will notice it, and mark it as InService, starting to redirect requests to that instance.Pretty nice. We can now configure our app to perform requests to the balancer and the problem is solved.<h3>Configuring the AWS load balancer</h3>When configuring the load balancer for the vault instances, we just need to take into account a few things.First, the balancer should be a classic load balancer, and it has to be configured as internal. This makes the balancer name resolve to the private IP address, and therefore, you prevent anyone accessing vault from the outside.It should also be configured to forward HTTP traffic on port 8200 (vault works on this port)<img src="%7B%7Bsite.url%7D%7D/assets/img/vault-with-load-balancer/balancer-first-step.png" alt="Load balancer"/>Then, when you are asked to configure the health check, use this params.<img src="%7B%7Bsite.url%7D%7D/assets/img/vault-with-load-balancer/health-check.png" alt="Health check"/>Configure the interval and healthy threshold according to your needs. Since for me it is a critical service, I reduced the interval to 15 seconds, and set the healthy threshold to 2. This way, when tha active instances goes down, it wont take more than 30 seconds to recover the service.Finally add the instances to the balancer.If everything is properly configured, after some seconds, in the instances tab of the balancer, you should see that only one of the instances is InService.<img src="%7B%7Bsite.url%7D%7D/assets/img/vault-with-load-balancer/instances-status.png" alt="Instances status"/>Now the balancer and the vault instances are ready to work!

Alejandro Celaya | Blog

Software development, agile methodologies and open source projects.

category Archive — "tools"

— 2022 —

— 2021 —

— 2020 —

— 2019 —

— 2018 —

— 2017 —