Testing PHP projects
This guide covers basic building instructions for PHP projects.
There are covered two cases: testing using the Docker executor and testing using the Shell executor.
Test PHP projects using the Docker executor
While it is possible to test PHP apps on any system, this would require manual configuration from the developer. To overcome this we will be using the official PHP docker image that can be found in Docker Hub.
This will allow us to test PHP projects against different versions of PHP. However, not everything is plug 'n' play, you still need to onfigure some things manually.
As with every build, you need to create a valid
.gitlab-ci.yml describing the
Let's first specify the PHP image that will be used for the build process (you can read more about what an image means in the Runner's lingo reading about Using Docker images).
Start by adding the image to your
The official images are great, but they lack a few useful tools for testing. We need to first prepare the build environment. A way to overcome this is to create a script which installs all prerequisites prior the actual testing is done.
Let's create a
ci/docker_install.sh file in the root directory of our
repository with the following content:
#!/bin/bash # We need to install dependencies only for Docker [[ ! -e /.dockerinit ]] && exit 0 set -xe # Install git (the php image doesn't have it) which is required by composer apt-get update -yqq apt-get install git -yqq # Install phpunit, the tool that we will use for testing curl -o /usr/local/bin/phpunit https://phar.phpunit.de/phpunit.phar chmod +x /usr/local/bin/phpunit # Install mysql driver # Here you can install any other extension that you need docker-php-ext-install pdo_mysql
You might wonder what
docker-php-ext-install is. In short, it is a script
provided by the official php docker image that you can use to easilly install
extensions. For more information read the the documentation at
Now that we created the script that contains all prerequisites for our build
environment, let's add it in
... before_script: - bash ci/docker_install.sh > /dev/null ...
Last step, run the actual tests using
... test:app: script: - phpunit --configuration phpunit_myapp.xml ...
Finally, commit your files and push them to GitLab to see your build succeeding (or failing).
.gitlab-ci.yml should look similar to this:
# Select image from https://hub.docker.com/_/php/ image: php:5.6 before_script: # Install dependencies - ci/docker_install.sh > /dev/null test:app: script: - phpunit --configuration phpunit_myapp.xml
Test against different PHP versions in Docker builds
Testing against multiple versions of PHP is super easy. Just add another job with a different docker image version and the runner will do the rest:
before_script: # Install dependencies - ci/docker_install.sh > /dev/null # We test PHP5.6 test:5.6: image: php:5.6 script: - phpunit --configuration phpunit_myapp.xml # We test PHP7.0 (good luck with that) test:7.0: image: php:7.0 script: - phpunit --configuration phpunit_myapp.xml
Custom PHP configuration in Docker builds
There are times where you will need to customise your PHP environment by
.ini file into
/usr/local/etc/php/conf.d/. For that purpose
before_script: - cp my_php.ini /usr/local/etc/php/conf.d/test.ini
my_php.ini must be present in the root directory of your repository.
Test PHP projects using the Shell executor
The shell executor runs your builds in a terminal session on your server. Thus, in order to test your projects you first need to make sure that all dependencies are installed.
For example, in a VM running Debian 8 we first update the cache, then we
sudo apt-get update -y sudo apt-get install -y phpunit php5-mysql
Next, add the following snippet to your
test:app: script: - phpunit --configuration phpunit_myapp.xml
Finally, push to GitLab and let the tests begin!
Test against different PHP versions in Shell builds
The phpenv project allows you to easily manage different versions of PHP each with its own config. This is specially usefull when testing PHP projects with the Shell executor.
You will have to install it on your build machine under the
user following the upstream installation guide.
Using phpenv also allows to easily configure the PHP environment with:
phpenv config-add my_config.ini
Important note: It seems
is abandoned. There is a fork
at madumlao/phpenv that tries to bring
the project back to life. CHH/phpenv also
seems like a good alternative. Picking any of the mentioned tools will work
with the basic phpenv commands. Guiding you to choose the right phpenv is out
of the scope of this tutorial.
Install custom extensions
Since this is a pretty bare installation of the PHP environment, you may need some extensions that are not currently present on the build machine.
To install additional extensions simply execute:
pecl install <extension>
It's not advised to add this to
.gitlab-ci.yml. You should execute this
command once, only to setup the build environment.
Extend your tests
Instead of PHPUnit, you can use any other tool to run unit tests. For example you can use atoum:
before_script: - wget http://downloads.atoum.org/nightly/mageekguy.atoum.phar test:atoum: script: - php mageekguy.atoum.phar
The majority of the PHP projects use Composer for managing their PHP packages.
In order to execute Composer before running your tests, simply add the
following in your
... # Composer stores all downloaded packages in the vendor/ directory. # Do not use the following if the vendor/ directory is commited to # your git repository. cache: paths: - vendor/ before_script: # Install composer dependencies - curl -sS https://getcomposer.org/installer | php - php composer.phar install ...
Access private packages / dependencies
If your test suite needs to access a private repository, you need to configure the SSH keys in order to be able to clone it.
Use databases or other services
Most of the time you will need a running database in order for your tests to
run. If you are using the Docker executor you can leverage Docker's ability to
link to other containers. In GitLab Runner lingo, this can be achieved by
This functionality is covered in the CI services documentation.
Testing things locally
With GitLab Runner 1.0 you can also test any changes locally. From your terminal execute:
# Check using docker executor gitlab-runner exec docker test:app # Check using shell executor gitlab-runner exec shell test:app
Want to hack on it? Simply fork it, commit and push your changes. Within a few moments the changes will be picked by a public runner and the build will begin.