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

Any medium and large project has to deal at some point with the problem of translating the application itself to other languages. There are many tools and standards to do this, but one of my favourite components is <a target="_blank" rel="noopener noreferrer" href="https://zf2.readthedocs.org/en/latest/modules/zend.i18n.translating.html">Zend\I18n</a>.Everybody who knows me is aware that I love Zend Framework, but unfortunately it&#x27;s been a while since the last time I worked on a project based on it.But nowadays that is not a problem. <a target="_blank" rel="noopener noreferrer" href="https://getcomposer.org/">Composer</a> allows you to install any component or library on any project, so I&#x27;m indeed constantly using many ZF2 components.I&#x27;m going to explain how to use one of those components, Zend\I18n, to manage application translations, which is a component that internally uses the <code>intl</code> PHP extension, so make sure to have it installed.<h3>Installation</h3>As usual, this component is easily installable with composer by running this command.<pre><pre><code>composer require zendframework/zend-i18n:~2.2
</code></pre></pre>If you want, I&#x27;ve created an example project that I&#x27;m going to use on this article. You can find it <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/internationalization">here</a>, just clone it and run <code>composer update</code>.Then go to the public directory, run <code>php -S 0.0.0.0:8000</code> and navigate to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8000">localhost:8000</a><blockquote>If you are not familiar with composer, take a look at this <a href="/2014/07/19/dependency-management-and-autoloading-in-php-projects-with-composer/">article</a>.</blockquote><h3>Translation files</h3>The first we need to decide is the way we are going to store translations. There are many supported formats, from plain PHP arrays where we set a translation key and the text in a language, to <a target="_blank" rel="noopener noreferrer" href="https://www.gnu.org/software/gettext/">gettext</a> files that can be automatically updated with new strings to be translated, but we could also use xml or ini files.The preferred method when using Zend\I18n is gettext (and it would be also my choice). It is easy to configure, uses super fast binary files in production and we don&#x27;t need to define translations immediately, we can leave it for then, so that it doesn&#x27;t break the development flow.Gettext files are usually handled with an external tool, <a target="_blank" rel="noopener noreferrer" href="https://poedit.net/">poedit</a>, an open source cross-platform application that can inspect our project and find new translations, deleted translations and updated translations, syncing our translation files (usually those with <code>po</code> extension) so that we don&#x27;t need to remember where we added or updated internationalizable texts.To do this we just need to tell the program the name of the functions we use to translate strings (usually <code>translate</code>, <code>gettext</code>, <code>_</code> and such) and the files it needs to scan for new translations.It also compiles and generates the binary <code>.mo</code> files, which are the ones used by the application.<h3>The translator</h3>Once we have decided the format of the files that are going to store translations, we have to create the main <code>Zend\I18n\Translator\Translator</code> object that is going to be used to find translations by consuming certain configuration.In the example, the <code>src/translator.php</code> file generates and returns a <code>Translator</code> instance. You will need to register your object in some kind of service container so that you can inject it anywhere. This example is so simple, that I just included the file in the index.php.The <code>Translator</code> has a factory method that is able to consume a configuration to generate the instance. It looks like this.<pre><pre><code class="language-php">use Zend\I18n\Translator\Translator;

return Translator::factory([
 &#x27;locale&#x27; =&gt; &#x27;en&#x27;,
 &#x27;translation_file_patterns&#x27; =&gt; [
 [
 &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../languages&#x27;,
 &#x27;type&#x27; =&gt; &#x27;gettext&#x27;,
 &#x27;pattern&#x27; =&gt; &#x27;%s.mo&#x27;,
 ],
 [
 &#x27;base_dir&#x27; =&gt; __DIR__ . &#x27;/../more_languages&#x27;,
 &#x27;type&#x27; =&gt; &#x27;phpArray&#x27;,
 &#x27;pattern&#x27; =&gt; &#x27;%s.lang.php&#x27;,
 ],
 ],
]);
</code></pre></pre>In the configuration we have to define the default locale. It can be only one or an array with many of them, so that the translator can load another language if it is not able to find the first one. The locale can be changed later, but it is a good idea to have a language by default.Then we have to define a list of places to find translation files. Each specification must include the directory which stores the files, the format of the translations in that directory (we can mix gettext with arrays and ini files if we want) and finally the pattern used to find certain translation file. The first mask will be replaced with the locale that is being used at each moment. This way, if we try to translate a message to the locale en, in the first directory, it will look for a file with the name <code>en.mo</code>I have not included it in the example, but we could also set a cache storage to be used with each translations directory under the &#x27;cache&#x27; key, but then we will need to install <code>zendframework/zend-cache</code> too.<h3>Translating texts</h3>Our translator is now ready to be used. In the example, the <code>public/index.php</code> file makes use of the translator to translate a couple strings.The translator works this way, when you call the methods <code>translate</code> or <code>translatePlural</code> with a string, it tries to find the translation in current locale. If it does, it will return it, otherwise it will return the original string.This way we can use the default language (usually english) for keys and avoid to generate translation files for that language.I have configured my <code>po</code> files so that poedit looks for the usage of the <code>translate</code> method inside the public directory, and assume the first argument is the string to be translated.At the top of the file you will see that I get a <code>lang</code> query param to use it as the current locale. If it is not defined or you define one that is invalid, the default locale <code>en</code> will be used.Now you can test it. It has three valid locales, en, es and fr. Use them to see the texts in English, Spanish and French. You can try to use an invalid locale too and you will see the texts in english.The last string is not included in any translation file, so you will see it always in english.<h3>Conclusion</h3>This is it. The translator is a simple component to use on any PHP project. It has more power in Zend Framework based applications, since it can be created by using the ServiceManager, and includes view helpers and integration with forms, but even so it can be used in isolation.I would like to discuss about advanced concpets of the translator, like text domains, plural forms and even some kind of front-end integration to use the same translation files under javascript environments, but that will be done in another article.

Translations and internationalization in PHP projects with Zend\I18n

We are all very used to file uploads in plenty of web applications. From simple image uploads to a social network to multiple file uploads to file management applications like Dropbox.On this article I&#x27;m going to explain how to handle asynchronous multifile uploads from a jQuery powered front-end to a Zend Framework 2 back-end, including HTML5 upload progress and file validation (type, size, and such).You will need a modern browser to do this, since asynchronous file uploads are not supported by old browsers. <h3>Installing example project</h3>I have created a project which is fully functional. I&#x27;m going to use it across this article so feel free to clone it from here <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/file-uploads">https://github.com/acelaya-blog/file-uploads</a>.<blockquote>Notice that I&#x27;ve simplified the usual Zend Framework 2 project structure. It&#x27;s enough for this example, but maybe difficult to maintain if your project grows, so better use the <a target="_blank" rel="noopener noreferrer" href="https://github.com/zendframework/ZendSkeletonApplication">Skeleton Application</a> structure in real applications.</blockquote>Once you have it, open a terminal, go to the directory and run <code>php composer.phar selfupdate &amp;&amp; php composer.phar install</code>.Finally start the PHP built-in web server by running <code>cd public &amp;&amp; php -S localhost:8000</code>. Access to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8000">localhost:8000</a> in order to see the application.<h3>The front-end</h3>I assume you are familiar with file uploads in web environments. All we need is a file input with the attribute multiple, wrapped inside a form with enctype multipart/form-data. This will make the browser to send files to the server.<pre><pre><code class="language-html">&lt;form name=&quot;uploadFiles&quot; id=&quot;uploadFiles&quot; method=&quot;post&quot;
 action=&quot;/upload-files&quot; enctype=&quot;multipart/form-data&quot;&gt;
 &lt;input type=&quot;file&quot; name=&quot;files[]&quot; multiple&gt;
 &lt;button type=&quot;submit&quot; className=&quot;btn btn-primary&quot;&gt;Upload files&lt;/button&gt;
&lt;/form&gt;
</code></pre></pre>It&#x27;s important to add brackets to the name attribute in the file input, so that the content is treated like an array and the server can properly manage all the files.In this example I captured the form submit with javascript event handlers so that we can track the progress of the upload. It&#x27;s been set in <code>public/js/main.js</code>. In the <code>acelaya.uploadFiles</code> function I have defined what has to be done when the form is sent.<pre><pre><code class="language-javascript">// [..]

uploadFiles: function ($form) {
 var action = $form.attr(&#x27;action&#x27;),
 method = $form.attr(&#x27;method&#x27;);

 $.ajax({
 url: action,
 type: method,
 data: new FormData($form[0]),
 cache: false,
 contentType: false,
 processData: false,
 xhr: function () {
 // This will make the ajax request to use a custom XHR object which will handle the progress
 var myXhr = $.ajaxSettings.xhr();
 if (myXhr.upload) {
 var progressBar = acelaya.createProgressBar($form);

 // Add progress event handler
 myXhr.upload.addEventListener(&#x27;progress&#x27;, function(e) {
 acelaya.handleUploadProgress(e, progressBar);
 }, false);
 myXhr.upload.addEventListener(&#x27;load&#x27;, function() {
 // Firefox does not trigger the &#x27;progress&#x27; event when upload is 100%.
 // This forces progress to end when upload is successful
 progressBar.find(&#x27;.progress-bar&#x27;).css({width : &#x27;100%&#x27;});
 }, false);
 }

 return myXhr;
 }
 }).done(function (resp) {
 if (resp.code === &#x27;success&#x27;) {
 acelaya.refreshFilesList();
 } else {
 $form.after(
 &#x27;&lt;div className=&quot;alert alert-danger alert-dismissable&quot; style=&quot;margin-top: 20px&quot;&gt;&#x27; +
 &#x27;&lt;button type=&quot;button&quot; className=&quot;close&quot; data-dismiss=&quot;alert&quot;&gt;&lt;span&gt;&amp;times;&lt;/span&gt;&lt;/button&gt;&#x27; +
 &#x27;&lt;div&gt;An error occurred with uploaded files&lt;/div&gt;&#x27; +
 &#x27;&lt;/div&gt;&#x27;
 )
 }
 });
},

// [..]
</code></pre></pre>If you are familiar with <code>jQuery</code> you have probably used the <code>ajax</code> method.In this case I&#x27;ve used the HTML5 <code>FormData</code> object to encapsulate the form element. This way any information on it will be serialized and sent to the server asynchronously, including files.By default the <code>ajax</code> method creates a <code>jqXHR</code> object (a wrapper of the native <code>XMLHttpRequest</code> object) with default behavior, but we need to extend that behavior, so we have to create a new one which will handle the upload progress too.What we do is to add a <code>progress</code> event listener which will increase a <a target="_blank" rel="noopener noreferrer" href="https://getbootstrap.com/components/#progress">bootstrap styled</a> progress bar as long as the content is sent to the server. The method <code>acelaya.createProgressBar</code> will create that progress bar and add it to the DOM.<pre><pre><code class="language-javascript">handleUploadProgress: function (e, progressBar) {
 if (! e.lengthComputable) {
 return;
 }

 var percent = e.total &gt; 0 ? e.loaded * 100 / e.total : 100;
 progressBar.find(&#x27;.progress-bar&#x27;).css({width : percent + &#x27;%&#x27;});
 progressBar.find(&#x27;.progress-bar&#x27;).text(parseInt(percent) + &#x27;%&#x27;);
},
</code></pre></pre>The method attached to the <code>progress</code> listener will be called by the browser for every chunk of data sent to the server. The number of times it is called dependes on the browser. For example, Firefox will call it more frequently than Chrome.The event object contains the total size of the data and the size that has been already sent, but also it has a boolean property lengthComputable that tells if size could be calculated.In the method <code>acelaya.handleUploadProgress</code> we calculate the percentage of the data that has been sent to display it in the progress bar.<blockquote>When you test this application, make sure to use big files, at least 1 GB in total, since you are going to &quot;upload&quot; them to your local machine, which is pretty fast. I already managed the server side to allow up to 1.5GB of POST data.</blockquote>Once files are uploaded, if the server returns a success response, we refresh the list of files, otherwise an error message is displayed.And this is everything for the front-end, but this is not enough to make a usable application since files uplaoded will be discarded at the end of the request if the server does nothing with them.<h3>The back-end</h3>Zend Framework 2 has some mechanisms to deal with uploaded files. Once we have defined our routes and controllers, we have to get those files and move them to its final location, which is pretty simple with the <code>Params</code> controller plugin.<pre><pre><code class="language-php">public function uploadAction()
{
 $files = $this-&gt;params()-&gt;fromFiles(&#x27;files&#x27;);
 $code = $this-&gt;filesService-&gt;persistFiles($files);
 return new JsonModel([
 &#x27;code&#x27; =&gt; $code
 ]);
}
</code></pre></pre>I have created a FilesService (<code>src/Service/FilesService.php</code> in the project) which gets injected in the controller to handle operations with files. In this case I call the method <code>persistFiles</code>, which should store the files in a folder and return a status code which is in turn returned to the client in a JSON response. This is what the method <code>persistFiles</code> does.<pre><pre><code class="language-php">public function persistFiles(array $files)
{
 foreach ($files as $file) {
 move_uploaded_file($file[&#x27;tmp_name&#x27;], $this-&gt;options-&gt;getBasePath() . &#x27;/&#x27; . $file[&#x27;name&#x27;]);
 }
 return self::CODE_SUCCESS;
}
</code></pre></pre>As you can see, it is pretty simple. It just iterates the list of files and performs a <code>move_uploaded_file</code> over each one of them. The options object wrapps the base path, which can be set at <code>config/config.php</code> by changing the <code>files.base_path</code> directive, and it is the <code>files</code> directory by default.This is functional, but we could need to validate something, like filesizes, mimetypes and such. We could even want to apply a hash to ensure an uploaded file&#x27;s integrity or check an uploaded image resolution.Zend Framework 2 comes with a full set of file validators that we can use on this example. <h3>Filtering and validation</h3>Let&#x27;s imagine we don&#x27;t want to allow files greater than 1.5GB (which is actually the maximum I&#x27;ve set by php configuration, but they don&#x27;t need to coincide) and that a file with the same name doesn&#x27;t exist yet. We are also going to ensure the file has been uploaded.We need now to define an <code>InputFilter</code> object that the <code>FileService</code> will apply to all the files. If any one of them fails validation, an error will be returned.<pre><pre><code class="language-php">&lt;?php
namespace Acelaya\Files;

use Zend\Filter\File\RenameUpload;
use Zend\InputFilter\FileInput;
use Zend\InputFilter\InputFilter;
use Zend\Validator\File\Size;

class FilesInputFilter extends InputFilter
{
 const FILE = &#x27;file&#x27;;

 public function __construct(FilesOptions $options)
 {
 $input = new FileInput(self::FILE);
 $input-&gt;getValidatorChain()-&gt;attach(new Size([&#x27;max&#x27; =&gt; $options-&gt;getMaxSize()]));
 $input-&gt;getFilterChain()-&gt;attach(new RenameUpload([
 &#x27;overwrite&#x27; =&gt; false,
 &#x27;use_upload_name&#x27; =&gt; true,
 &#x27;target&#x27; =&gt; $options-&gt;getBasePath()
 ]));

 $this-&gt;add($input);
 }
}
</code></pre></pre>This filter will check each file has a file size no greater than what we defined in our configuration by using the <code>Size</code> validator.Also, the <code>RenameUpload</code> filter will try to move the file to our previously defined base path by calling the <code>move_uploaded_file</code> function, which will only work with uploaded files, and throw an exception if we try to override an existing file.We just need to adapt our <code>FilesService::persistFiles</code> method to use this <code>InputFilter</code>.<pre><pre><code class="language-php">public function persistFiles(array $files)
{
 foreach ($files as $file) {
 $filter = clone $this-&gt;getInputFilter();
 $filter-&gt;setData([FilesInputFilter::FILE =&gt; $file]);
 try {
 if (! $filter-&gt;isValid()) {
 return self::CODE_ERROR;
 }
 $data = $filter-&gt;getValues();
 } catch (InvalidArgumentException $e) {
 return self::CODE_ERROR;
 }
 }
 return self::CODE_SUCCESS;
}
</code></pre></pre>The <code>getInputFilter()</code> method returns an instance of our <code>FilesInputFilter</code>. After that we apply validation and if no exception is thrown and the method <code>isValid()</code> returns true, then everything worked and we can continue with the next file. If an error occurred we return the ERROR code.It is important to call <code>$filter-&gt;getValues()</code> even if we are not going to use them, because that is what makes the function <code>move_uploaded_file</code> to be called, otherwise we won&#x27;t get the files moved to their final directory.Now the application keeps working, but our uploaded files are filtered and validated.Zend Framework 2 has other <a target="_blank" rel="noopener noreferrer" href="https://zf2.readthedocs.org/en/latest/modules/zend.filter.file.html">filters</a> and <a target="_blank" rel="noopener noreferrer" href="http://zf2.readthedocs.org/en/latest/modules/zend.validator.file.html">validators</a> you can use with files. Take a look at them.And this is it. We have our fully functional file uploading application.

File uploads with Zend Framework 2 and jQuery

Setting up a development environment is not always easy, specially for web development. Sometimes you need to install and configure plenty of applications. A database server, a web server, server-side programming language binaries, mail server, job queue server, specific package managers, building tools, debug and profiling tools, etc.Each one of them will need to be in a concrete version, and you will need to handle their dependencies too. You could think that&#x27;s a one time task, but what happens when you work on multiple projects at the same time. You need to install that for each one of them, and also make sure there are no conflicts with different environments.There is a tool that eases this task, called <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/">Vagrant</a>, that allows us to create a virtualized environments with all the tools, system packages and applications we need to use in a project. Each environment is running on its own virtual machine, so there is no conflicts between them.The configuration of each virtual machine is defined in a file, that can be pushed to the VCS server, so that any other team member can use the same exact environment as you. By using that file, Vagrant creates a machine, downloads the OS and installs it, installs the packages and starts services, so that we can start working in no time.This is a much more efficient way to work, since that configuration file (called Vagrantfile) can be reused multiple times.<h3>Installing vagrant</h3>Vagrant is a command line tool which eases the interaction with the virtual machines. Start a machine, halt a machine open a SSH connection or refresh the configuration by reading the Vagrantfile are easy tasks which only need a certain command to be executed.There are packages for every major operating system that can be downloaded from <a target="_blank" rel="noopener noreferrer" href="https://www.vagrantup.com/downloads.html">here</a>.You will also need to install <a target="_blank" rel="noopener noreferrer" href="https://www.virtualbox.org/wiki/Downloads">VirtualBox</a> to handle virtual machines. Others are supported too.<h3>Creating the Vagrantfile</h3>The Vagrantfile is the main configuration file for the virtual machine. It defines the operating system to be used, the system packages to be installed and how to do it, ports to be mapped to the host machine, folders to be shared, etc.It is usually placed in the root directory of your project, since the folder containing it will be mapped to the folder <code>/vagrant</code> inside the virtual machine. This way the complete project will be available inside the virtual machine, for example to be served by a web server. A simple example of a Vagrantfile could be this.<pre><pre><code class="language-ruby">Vagrant.configure(&quot;2&quot;) do |config|
 
 # This is the operating system to be installed. Ubuntu 12.04 in this case
 config.vm.box = &quot;hashicorp/precise32&quot;
 
 # The script &quot;bootstrap.sh&quot; will we run within the virtual machine once installed
 config.vm.provision :shell, path: &quot;bootstrap.sh&quot;
 
 # The port 8888 will be forwarded from the local machine to the virtual machine&#x27;s port 80
 config.vm.network :forwarded_port, host: 8888, guest: 80
 
end
</code></pre></pre>This is very easy to undertand. We are telling vagrant to install Ubuntu 12.04, start the machine and run the bootstrap.sh script, which could be used to define which system packages to install.Then, we forward the port 8888 in the local machine to the port 80 in the virtual machine, so that we can see the application by accessing to <code>http://localhost:8888</code>.You have an example project using this Vagrantfile <a target="_blank" rel="noopener noreferrer" href="https://github.com/acelaya-blog/vagrant">here</a>. Clone it, go to the folder and run <code>vagrant up</code>. Once it finishes go to <a target="_blank" rel="noopener noreferrer" href="http://localhost:8888">http://localhost:8888</a> and you should see a nice Hello World! which is being served from the virtual machine.However, this example is too simple. In real projects we usually have more complex requirements, and configuring the complete Vagrantfile is not so easy.For this situations, we have multiple online assistants which can be used to create more complex Vagrantfiles. One of the best for PHP projects is <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>, which is based on Puppet.<h3>Setting up the machine</h3>The first step is to go to <a target="_blank" rel="noopener noreferrer" href="https://puphpet.com">PuPHPet</a>&#x27;s webpage and follow the steps of the wizard. Select the operating system to be installed, the web server, the PHP version and such, the result depends on your needs. Once you finish this you will be able to download a complete configuration file.Extract downloaded file wherever you want, open a console and go to the extracted folder. Now run <code>vagrant up</code> and the machine will be created and configured. This process may take some time, so be patient.After a while, the virtual machine will be up an running. You can take a look at the extracted Vagrantfile and see that it is a little more complex than the first example.If you include the Vagrantfile and the puphpet folder in your project&#x27;s VCS you will be able to reproduce the same environment anywhere you go just by clonning the repository.<h3>Guest and host machine integrations</h3>SSH access: One of the more common things we&#x27;ll need to do is to open a SSH connection against the virtual machine. To accomplish that task we just need to go to the folder where the Vagrantfile lives, or one of its subfolders and run <code>vagrant ssh</code>. Now you are able to do anything on the virtual machine as if it were your host machine.Folders sync: Another thing we&#x27;ll probably need to do is to sync folders between the host machine and the guest machine. As I said earlier, the Vagrantfile parent folder is mapped by default to the <code>/vagrant</code> folder in the virtual machine, but we could change the folders in case of need.To define a folder that should be synced, just place a line like this in your Vagrantfile.<pre><pre><code class="language-ruby">config.vm.synced_folder &quot;subfolder/&quot;, &quot;/anywhere/else/in/the/virtual/machine&quot;
</code></pre></pre>Port forwarding: This was seen in the first example. We could map a port in the host machine to another port in the virtual machine so that requests to the first one are forwarded to the other. We could also access the virtual machine IP or hostname directly, that depends on our needs.<h3>Managing virtual machines</h3>After some time working with vagrant you&#x27;ll probably have more than one virtual machine created and vagrant also provides some commands to handle them. By the way, the virtual machines in vagrant are called boxes.We have seen that the <code>vagrant up</code> command creates a virtual machine, but it also turns on a previously halted box. To safely halt a virtual machine, just run <code>vagrant halt</code> and all the resources will be freed. We have also the <code>vagrant suspend</code> which, as you can guess, is used to suspend a box and <code>vagrant resume</code>, which resumes a suspended box.Sometimes we will need to update a virtual machine. Updating the Vagrantfile and running the <code>vagrant up</code> command is not enugh for already created boxes, you will need to run <code>vagrant reload</code> so that the Vagrantfile is processed again. If you also need to refresh the provisions (the bootstrap.sh script in our first example) either run <code>vagrant provision</code> or <code>vagrant reload --provision</code> which will both reload the configuration and provision the machine.Finally, when you need to delete a virtual machine, just run <code>vagrant destroy</code>.You can also manage all the boxes you have installed, without having to be in the directory of a specific machine, by using the commands under <code>vagrant box</code>. Try <code>vagrant box help</code> to see what&#x27;s available.<h3>Conclusion</h3>This is pretty much it. This will let you encapsulate a PHP project inside a virtual machine, allowing you to use different applications and services on each one of them and &quot;tracking&quot; the state of the machine itself so that any collaborator can work in the same environment as you.Of course there are other advanced usages for Vagrant, like deployment of machines to virtualization systems like Amazon Web Services, but that&#x27;s another articles subject.For a complete vagrant documentation, follow this <a target="_blank" rel="noopener noreferrer" href="https://docs.vagrantup.com/v2/getting-started/index.html">link</a>.