Testing is important — most people understand that by now. A lot of people write tests for their open source code already, but in-house testing is still hard. For example, many of us had an encounter with Jenkins: it runs well to a point where it becomes harder to maintain the Jenkins than it is to write tests.
Another obstacle is test setup and environments: When I write and run tests, there is sometimes only so much I can do to mock and avoid actual calls to my storage backend. While I prefer to run my database tests against a SQLite in memory database, there are these edge cases, where I work with multiple database or I write a direct query (and by-pass the ORM-magic).
In these cases I need to have that database server available in my test environment!
The following blog posts explains how to solve these things with Travis-CI. I will walk you through the setup on Travis-CI's business service. But most of this applies to their open source offering as well.
Step by step
I'll try to break it up into small steps.
Travis-CI
The first step is to login at http://travis-ci.com and add the repository tests should be run for. To be able to add repositories of an organization, you have to be the owner of the organization. The easiest way to get access to the service right now is donating to these guys or in case you have done that already: email them. ;-)
The second step is setting up a .travis.yml file.
Mine looks like this:
language: php
php:
- 5.3
- 5.4
before_script:
- ./composer.phar -v install --dev
- psql -c 'create database testdatabase;' -U postgres
Run-down:
- run the tests against PHP 5.3 and 5.4
before_script defines your test setup (outside PHP)- I omitted the
script stanza because the default (phpunit) works for me
Composer
I am using composer to manage my dependencies and you should too. I don't want to go into details here, but a short example of my composer.json is the following:
{
"name": "mycompany/project",
"description": "A super cool project.",
"require": {
"doctrine/orm": "2.2.2"
},
"autoload": {
"psr-0": {
"MyCompany\\Project\\Test": "tests/",
"MyCompany\\Project": "src/"
}
}
}
Side-note: We also currently commit a composer.phar into each repository for two reasons:
- To ensure a change in composer won't break our setup.
- Downtime of (or connectivity issues to) their website don't break our deployments and test runs.
Test framework setup
There is not a whole lot to setup since Travis-CI installs phpunit already. Just make sure you have a phpunit.xml in the root of your repository and you are good to go.
Database schema
The next step would be to generate your schema and check in some .sql, right? I'm not a huge fan of this, because I hate running through a lot of manual steps when I need to update something. Manual steps means that they might be forgotten or people make a mistake. So the objective is to avoid any manual labour as much as you can.
Instead of maintaining these files, I use Doctrine's SchemaTool. It takes care of this just fine because I annotated all my entities already.
To make use of this, I suggest to add the following to your test case:
<?php
namespace MyCompany\Project\Test;
use Doctrine\ORM\Tools\Setup;
use Doctrine\ORM\EntityManager;
use Doctrine\Common\Persistence\PersistentObject;
use Doctrine\ORM\Tools\SchemaTool;
class MyTestCase extends \PHPUnit_Framework_Testcase
{
protected $em, $tool;
public function setUp()
{
$this->setUpDatabase(); // wrap this again
$this->setUpSchema();
/* more setup here */
}
public function tearDown()
{
$classes = array(
$this->em->getClassMetadata('MyCompany\Project\Entity\SomethingImportant'),
);
$this->tool->dropSchema($classes);
unset($tool);
unset($em);
}
public function setUpDatabase()
{
$isDevMode = true;
$doctrineConfig = Setup::createAnnotationMetadataConfiguration(
array('path/to/Entity'),
$isDevMode
);
// database configuration parameters
$dbConfig = array(
'host' => '127.0.0.1',
'user' => 'postgres',
'password' => '',
'dbname' => 'testdatabase',
);
$this->em = EntityManager::create($dbConfig, $doctrineConfig);
PersistentObject::setObjectManager($this->em);
}
public function setUpSchema()
{
$this->tool = new SchemaTool($this->em);
$classes = array(
$this->em->getClassMetadata('MyCompany\Project\Entity\SomethingImportant'),
);
$this->tool->createSchema($classes);
}
}
Assumptions made (aka, room for improvement):
- your entities are in
path/to/Entity
- PostgreSQL is used and runs on
127.0.0.1
- you're using a database called
testdatabase
Tests
Once the setup is complete, I add the usual testFoo() methods into my test case class.
From within the testFoo() methods I have Doctrine's EntityManager available via $this->em. The entity manager allows me to do whatever I need or want within a test run.
After a test completes, the tearDown() method is invoked and destroys the tables in your testdatabase and then setUp() re-creates it. This will take some time but the side-effects of stale data are not to be neglected. Add to that, your tests should not rely on the order they are executed in anyway.
Another benefit of this setup are updated SQL tables each time a commit changes the annotations. No extra .sql files to maintain. :)
Fin
That's really all there is to running your test suite with Travis-CI and while you did all the above, you just added continuous integration to your toolkit because these tests run each time a pul request is opened or commits are pushed. :-)
As I mentioned early on, these steps apply to the open source offering as well — all but the link to login.
If PostgreSQL is not your game, have a look at the list of currently supported databases on Travis-CI. And if your database server is not on the list of supported applications, you might as well install it with a before_script (as long as it runs on Ubuntu). ;-)
Happy testing!