This relese fixes two reported bugs.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package. It's important to update Codeception now.
In next releases an automatic updater will be added.
As you may know, Codeception a BDD-style testing framework has tools for cleaning up tested database between tests. This week tools for database repopulation in Codeception were improved and it's usage was covered in new chapter of Guides. To get your database populated before tests, just provide an SQL dump and set up PDO connection. For functional and unit testing best way to clean up your database faster is not to pollute it at all. All database queries can be taken into transaction and rolled back at test end. This behavior is introduced within new Dbh module, and in ORM modules for Doctrine1 and Doctrine2. To speed up data repopulation in acceptance tests we recommend you to move database to SQLite.
Database repopulation is the subject of the new Guide: Working with Data was started. It explains different strategies for database cleanups and usage of fixtures in Codeception.
Codeception is now tested for loading and cleaning up SQLite, MySQL, and PostgreSQL dumps.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package.
This Codeception release is all about minor but useful features. Starting from 1.0.3 you will be notified on every new Codeception release from console. If you are not running tests, Codeception Cli application will check for new version and notify you if it is available.
$ codecept
UPDATE: version 1.0.3 released. See changes on: http://codeception.com.
Codeception version 1.0.2
There are new generators for empty tests: Cest and Cept files. Empty test suite can be generated too. Just check new 'generate:' commands.
But the most interesting generation feature is Agile Documentation. From now you can improve your documentation generated by DocBlox by appending test scenarios into text. With Codeception BDD approach to Unit Tests it's easy to imagine every test as usage documentation.
The concept of Agile Documentation will be demonstrated in following example:
We have a sample static method for creating an entity Group. Which can be group of people in social network, for example. This method uses Doctrine 2 as ORM.
<?php
class Group {
// This creates new group by user
public static function create($name, $founder_id)
{
$em = self::$entityManager;
$group = new \Model\Group;
$group->setName($name);
$group->setUser($em->getRepository('Model\User')->find($founder_id));
$em->persist($group);
$em->flush();
return $group->getId();
}
}
?>
This method requires Id of user who creates group and group name. Here is test for this function:
<?php
public function create(\CodeGuy $I)
{
$user_id = Fixtures::get('valid_user')->getId();
$I->wantTo('create group');
$I->executeTestedMethodWith('DemoGroup', $user_id)
->seeInRepository('Model\Group', array('name' => 'DemoGroup', 'user_id' => $user_id, 'type' => 'group'))
->seeResultIs('int');
}
?>
This test is translated into documentation for Group::create method.
With this method I can create group
If I execute \Service\Group::create("DemoGroup",1)
I will see in repository "Model\Group",{"name":"DemoGroup","user_id": 1, "type": "group" }
I will see result is "int"
Codeception scans for all Cest files and for all classes passed to DocBlox. When tests match the function in documentation the test is processed and appended into function description.
To start using Codeception with DocBlox you should use the same project root for both projects, i.e. codeception.yml and docblox.xml should be in one directory. Include plugin into docblox.xml:
<plugins>
<plugin path="{FULL-PATH-TO-PEAR}/Codeception/plugins/DocBlox/Codeception">
</plugin>
</plugins>
As you see, you should specify path to PEAR explicitly. This is DocBlox limitation. Plugins can be either local or provided with DocBlox distribution. I'm not sure how to deal with current Codeception plugin for DocBlox, so I asked this question on GitHub. I hope in near future a better solution will be proposed.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package.
This release brings a real behavior driven development to Codeception. Before that we talked about testing in BDD-style, but nothing about real development by behavior. There were just few changes made in code. More changes are coming to documentation.
With Behavior Driven Development you start development of class by writing it's specifications. Specifications are written as methods of Cest class and start with 'should' word.
<?php
class EventMachineCest {
$class = 'EventMachine';
function shouldHaveInitialState() {}
function shouldMoveBetweenTransitions() {}
function shouldMoveBetweenTransitionsOnCondition() {}
}
?>
The EventMachine class in example above is not written, but we've already defined what to expect from it. After a basic requirements are specified we can take a deeper look into it and describe how it should be used. From this point your specifications become a valid Codeception tests.
<?php
class EventMachineCest {
$class = 'EventMachine';
/**
* @doc getState
*/
function shouldHaveInitialState(CodeGuy $I)
{
$em = new EventMachine;
$I->executeMethod($em, 'getState')
->seeResultEquals('initial');
}
}
?>
For full EventMachineCest example see my Gist on Github.
Codeception generates a pretty good documentation with DocBlox based on your scenario. The @doc annotation marks that a getState method documentation will be updated by current test scenario.
I want to have initial state
I execute method $eventMachine, 'getState'
I see result equals 'initial'
For making acceptnace tests usable for writing Stories we've added 2 new methods. It's am and lookForwardTo which represent 'As a ...' and 'So that' definitions from Story.
<?php
$I = new WebGuy();
$I->am('regular site user'); // As a regular user
$I->wantTo('create my blog page'); // I want to create my blog page
$I->lookForwardTo('get a cool blog here'); // So that I get a cool blog
$I->expect("blog can't be created twice");
$I->expect("blog has RSS feed");
$I->expect("am administrator of this blog");
?>
After that Cept can be extended in a valid Cept file. Refer to this Gist demonstrates for example.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package.
Almost every week Codeception gets a new release. I think it's quite good tempo. Every release contains not only bugfixes but a new features too. I'm satisfied but today's release, because all changes were made by new Codeception contributors. Thank you, guys!
A new module for Social Engine was created by Artem Kovradin. He took the code of Zend Framework module and adopted it for Social Engine, which is build with powered by Zend Framework. With now on, you can simply test you social networks built on top of Social Engine.
Also there were some encoding issues, but they are solved easily if you make sure your code and site has a UTF-8 encoding.
Thanks again to all contributors and reporters.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package.
That was quite a long time after last version was released. This time we decided to skip version 1.0.6, just because 1.0.7 looks prettier.
With this release Codeception can be used in CI systems like Jenkins. It's very easy: you just append '--xml' option for running test and receive xml report in JUnit format stored in 'tests/_log' directory. Other popular formats like Json and TAP were added too. Here is a sample report.xml generated by Codeception test suite:
<?xml version="1.0" encoding="UTF-8"?>
<testsuites>
<testsuite name="acceptance" tests="9" assertions="29" failures="0" errors="0" time="41.532108">
<testcase file="Cli\BuildCept.php" name="test build command (Cli\BuildCept.php)" assertions="5" time="4.016982"/>
<testcase file="Cli\GenerateCeptCept.php" name="generate sample cept (Cli\GenerateCeptCept.php)" assertions="5" time="15.401255"/>
<testcase file="Cli\GenerateCestCept.php" name="generate sample cest (Cli\GenerateCestCept.php)" assertions="3" time="3.742880"/>
<testcase file="Cli\GenerateScenariosCept.php" name="generate scenarios (Cli\GenerateScenariosCept.php)" assertions="3" time="3.668740"/>
<testcase file="Cli\GenerateSuiteCept.php" name="generate sample suite (Cli\GenerateSuiteCept.php)" assertions="4" time="4.706381"/>
<testcase file="Cli\RunWithHtmlCept.php" name="check xml reports (Cli\RunWithHtmlCept.php)" assertions="1" time="2.428402"/>
<testcase file="Cli\RunWithJsonCept.php" name="check json reports (Cli\RunWithJsonCept.php)" assertions="2" time="2.692029"/>
<testcase file="Cli\RunWithTapCept.php" name="check tap reports (Cli\RunWithTapCept.php)" assertions="2" time="2.459026"/>
<testcase file="Cli\RunWithXmlCept.php" name="check xml reports (Cli\RunWithXmlCept.php)" assertions="4" time="2.416413"/>
</testsuite>
</testsuites>
Currently this reports are not perfect as for different file formats and you may lack some important information. For this cases, please create issues on GitHub or in Q&A section.
Thanks to Nikita Groshin new module for Kohana Framework integration was added. Please, check it out for your Kohana projects and leave a feedback.
Also there were some encoding issues, but they are solved easily if you make sure your code and site has a UTF-8 encoding.
Thanks again to all contributors and reporters.
Please update your version via PEAR:
$ pear install codeception/Codeception
or download updated Phar package.
Also you should update Mink, as it uses Zend Framework 2 beta 3 now for PHP browser. All Codeception dependencies can be updated with a single command.
$ codecept install
From this release you can install Codeception via Composer. If you have fucked up with PEAR it's a good idea to try out brand new Composer. It allows you to install Codeception with all it's dependencies, even PHPUnit, without any usage of PEAR.
If you already use Composer add this lines int your composer.json to and update packages.
"require": {
"Codeception/Codeception": "*"
},
"repositories": {
"behat/mink-deps": {
"type": "composer",
"url": "behat.org"
}
}
From now on you can run Codeception with
php vendor/bin/codecept
If you are new to composer but you are troubled with PEAR, the installation guide is updated for you.
Except this significant (but simple change) this release is all about bugfixing.
With the help of GitHub users ilex and nike-17 Kohana module was improved. Do you want to have a module for other frameworks? Maybe Yii, Fuel, CodeIgniter or Zend Framework 2? It's really simple. You just need to write a proper connector and you can go with performing functional tests inside your application. Check the [Functional Testing]http://codeception.com/docs/05-FunctionalTests) section of documentation.
And some good news about documentation! Jon Phipps has done a great job on editing the docs. Soon it will be published here. I know my English is not perfect. So I really appreciate any help in editing and reviewing documentation or blog posts.
Thanks to Sergii Grebeniuk for a small patch on autoloading.
There was not too much unique features in this release. Maybe you have some ideas on what should be improved?
This evening I released Codeception 1.0.9. The most important thing you may notice is documentation. It's just better. It was improved by Jon Phipps. Better phrasing goes to better understanding, right? But let's move on to see the actual new features.
Two new modules were intoduced by Alexander Bogdanov @synchrone. It's new Selenium2 module and ZombieJS.
Ok, you may know about Selenium. But what is the purpose of Zombie?
Tools like ZombieJS, (PhantomJS, and more) are built in order to run tests without a browser. And so they are called headless. They don't require a browser window to start, they don't show any interactions on screen.
Why do we need browser for testing web applications? Only browser-based javascript engines can run all the client side code. ZombieJS is one of them, taken from browser and produced as a standalone tool. It's built with Node.js and requires Node.js, NPM, a C++ compiler and Python to install. Check out it's official site for more information.
Thanks to Mink from now on you can write ZombieJS tests inside Codeception just like tests for other cases.
Selenium and Selenium2 modules was updated with the new delay option. If Selenium performs actions faster the user, and javascript just can't catch it it, you can slow down the execution by setting the delay param. It's set in milliseconds and will perform pauses after each step in scenarios.
Seems like the PHP WebScrapper Goutte (which is used by PHPBroser module) has a new backend now. It has moved from Zend Framework 2 libraries to new lightweight HTTP client Guzzle. So, no more Zend dependencies and long stack trackes. This change doesn't affect PEAR users, cause this change arrive in PEAR packages yet.
Thanks again to all contributors and reporters.
Please update Codeception version via PEAR:
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
Codeception testing framework got significant improvements during last week. The first and the major one is that you don't even need PEAR and Composer to execute tests. Only one file codecept.phar required. This might save your time and mind of your testers.
So Installation is much simplier now:
Download archive.
Execute it with PHP php codecept.phar
Now you can start generating a test suite with php codecept.phar bootstrap or execute existing tests with php codecept.phar run.
Documentation section was created. New section Reference was added. There you can review Codeception commands and configuration values.
But the most cool stuff is new module for testing web services!
Modules for SOAP and REST were added recently. You know it's always hard to test the API manually. So why not to automate it?
This API modules keeps simple manner in describing tests. Take a look at sample REST test.
<?php
$I = new ApiGuy($scenario);
$I->wantTo('create a new user by API');
$I->amHttpAuthenticated('davert','123456');
$I->haveHttpHeader('Content-Type','application/x-www-form-urlencoded');
$I->sendPOST('/users', array('name' => 'davert' ));
$I->seeResponseCodeIs(200);
$I->seeResponseIsJson();
$I->seeResponseContainsJson(array('result' => 'ok'));
And here goes a sample SOAP test:
<?php
use \Codeception\Utils\Soap;
$I = new ApiGuy($scenario);
$I->wantTo('create a new user thorough API');
$I->haveSoapHeader('Auth', array('token' => '123123'));
$I->sendSoapRequest('CreateUser', Soap::request()
->User
->Name->val('davert')->parent()
->Email->val('davert@codeception.com');
);
$I->seeSoapResponseIncludes(Soap::response()->result->val(1));
Ok, the one thing you may have noticed. We are working with JSON in first case and XML in second. But there is no JSON or XML in code! Well, we could have used it, but we didn't. Just because we can use PHP to set data in this formats. Json is built from PHP arrays and for XML is used jQuery-like styled XMLBuilder class. But you could possibly add a raw json or XMl into your tests. No problems with that!
Modules themselves are already documented and tested. Soon a complete guide on WebService API testing will be added.
The other thing worth to mention is new finalizers in test scenarios. If you need to execute code after test is finished and you don't want to put it in helper use the $scenario->finilize method. See it's usage example in new Manual Cleanup section of Guides.
This is Codeception 1.0.11. Download new version to run tests or update
via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
Hi, that's been a while from the last release. But still Codeception is evolving. And today's release notes I'm going to start with some thoughts on Codeception installation strategy.
For a long time a PEAR was the primary method for install. It had some issues and develoeprs got stuck with it. Nowdays alternative is a [Composer[(http://packagist.org)] which Codeception uses too. But nevertheless we consider it a bit complex too. Codeception is tool where everything is kept simple. We are trying to make it work even for junior developers and testers. So our primary goal is to provide a standalone version 'codecept.phar' which was introduced recently. In future version we will try to make it autoupdate itself (as Composer does).
It's really cool cause it simplifies integration with CI systems and has less requirements to your PHP environment. Right now Codeception phar archive includes Symfony Components, Mink, PHPUnit in one file. So if you ever wanted to run PHPUnit tests without PEAR, the Codeception can be used that way too.
The major feature is related to current installation strategy. We finally added custom assertions to modules and user helper classes. Before that you should have used PHPUnit's static methods for assertions. But now you can just write this->assertXXX in a helper class.
In next example we connect PhpBrowser module to helper and use assertion to check a menu exists for current user.
<?php
class WebHelper extends \Codeception\Module {
function seeEditingToolsMenu()
{
$content = $this->getModule('PhpBrowser')->session->getPage()->getContent();
$this->assertContains('<a id="menu" href="#">Edit Post</a>',$content);
}
}
?>
The Helpers section in Guides was totally rewritten to represent this change and provide more examples.
In this release a new module WebDebug was intorduced. It provides means to make screenshots with a single command. In case a screenshot can't be saved, it tries at least save the HTML response to file. After the test you can review all saved files to see what actually happened during test.
Thanks to Andrey Popov for contributions.
click method for frameworks now accepts CSS selectors.This is Codeception 1.0.14. Download new version to run tests or update
via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
Hi, last week Codeception got it's first major update. Welcome the Codeception 1.1. Many core classes were refactored to solve the common issues and reduce the level of dark magic inside. Only white magic left. And that's really cool 'cause you don't need to study to source code to implement your custom hooks now. Codeception is rapidly evolving to be the professional testing tool, ready to use by testers and developers through out the PHP world.
Did you ever were wondered why you can't receive values in test and pass it to next steps? To do something like this:
<?php
$user_name = $I->grabTextFrom('#user_name');
$I->fillField('username', $user_name);
?>
Actually, there is no any good reason for not doing so. The only reason was - the code was not designed to execute test file in runtime. The steps were recorded, analyzed, and only then they were executed, without touching the test file again. That is the source of dark magic that was removed in Codeception 1.1. This magic was awful because you didn't control the test execution. So, usage of custom PHP code in test was leading to unpredictable results. Even simple tasks was encouraged to be done in helpers, not in test code itself, to be run properly.
So what changed in Codeception 1.1? There is no magic in test execution, test file is required and executed, that's all. Still the analyzes step is not skipped, so test is run two times: first to record scenario, validate and analyze all steps, second to execute them. With that simple idea you can use ANY php code in your tests if only you define the stage when it should be executed. The additional bootstrap files should be loaded one time before the analyses:
<?php
if ($scenario->preload()) {
require '_user_fixtures.php';
}
$I = new WebGuy($scenario);
$I->loginAs($user);
// ...
?>
And when you need something to be executed in runtime, like cleaning the fixture data, please use the following:
<?php
// ..
$I->loginAs($user);
$I->see('Hello, '.$user->name);
if ($scenario->running()) {
$user->delete();
}
?>
In this example user is removed in the very end of scenario. $scenario->running method allows you to execute any code in the runtime.
But please, always specify the stage when the custom code should be executed, or it will be executed 2 times.
In Codeception 1.0.x the build command was optional, when updating configuration. But now it's required to run every time the modules are added or removed in suite config file. That's the only new issue, but Guy-classes look much better now.
As the result of changed described above, you can finally return values to scenario and use them in next steps. The new grabbers commands were introduced:
<?php
$text = $I->grabTextFrom($element);
$value = $I->grabValueFrom($form_field);
$attr = $I->grabAttributeFrom($element, 'attribute');
$name = $I->grabFromDatabase('users', 'name', array('id' => 1));
// ....
?>
You can write your own grabbers. Just return values from your helper methods and you can use them in test. Please review the modules to see new commands there!
Codeception is a tool for testing, and many testers like specifying locators by XPath. CSS selectors have their limitations, so why not to use XPath in tests too? Sure, why not! You can freely use XPath selectors in your tests from now. But no new methods added for this! Really. The old methods were updated to support CSS and XPath as well. So whenever you need to pass a selector you can either pass CSS or XPath and Codeception is smart enough to guess what did you pass and how to use it.
<?php
$I->click('New User');
$I->click('#user_1 .user_new');
$I->click("descendant::*[@id = 'user_1']/descendant::a");
?>
All the methods where CSS was used were updated to support XPath. Try it!
There was no common idea how to deal with unit tests in Codeception. As you know, Codeception can run standard PHPUnit tests as well as the hybrid scenario-driven unit tests. Scenario driven tests for many cases looked to complex to use. But they allowed to use Codeception modules in them. Why not to provide standard PHPUnit tests to use Codeception features? For Codeception 1.1 the new chapter of Guides describing unit tests is written. In brief: you can use the CodeGuy class inside your tests! Include any modules and use it as you need it. Use them to perform database cleanups, use them to check values in database, use them to work with file system. They are just wonderful helpers in your work.
And yep, new unit tests can be generated by command: generate:test.
build command.Codeception 1.1 can be downloaded from site,
via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
P.S. Documentation was updated for 1.1 version.
Good news, everyone! Codeception 1.1.2 released. And it's hard to list everything that were improved and fixed, but i will try. With the help of our active contributor tiger.seo Codeception got an AMQP module wich allows to manipulate queue engines, like RabbitMQ. You can use this module if you need to clear queues between tests. Also, new Memcache module was introduced. You can perform simple checks and use data from your Memcache storage in tests. Guys, it's very simple to contribute to Codeception. All new modules are welcome, they can grow from your local helpers and become part of this library. Just fork Codeception, add a module and send me a pull request!
You should regenerate your guy-classes after this update with the build command. Rebuilt Guy-classes will contain full documentation for each method and link to the source code of underlying method. Also, with the help of tiger.seo Codeception got better PHPStorm integration. Codeception when run in PHPStorm console outputs stack traces that is recognized by PHPStorm. So you can click on any file name and move to it in IDE.
You know that there is --html option which saves results of running tests in HTML. But now you can save the test scenarios in HTML without running them. That's quite useful if you want to save test scenarios into your company's wiki. The HTML format can inserted into Confluence, for example. And now testers, managers, and developers will have the test scenarios up to date. Yep, thanks again to tiger.seo.
PEAR package was completely redesigned. Codeception is not using PEAR as a dependency manager anymore, Composer is ok. But PEAR is quite useful if you want a system-wide install, and simple call to Codeception with codecept command. PEAR package now contains all dependent modules and doesn't require PHPUnit or Mink installed anymore. That will prevent possible conflicts and reduce level of PEAR-related wtfs.
Codeception 1.1.2 can be downloaded from site,
via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
Codeception 1.1.3 and then 1.1.4 was released during last month. In this post I will summarize the changes happened in this minor updates. The 1.1.3 version fixed one bug pointed by Nastya Ahramenko. Yep, only one bug. But it was pretty cool for me to mention it and make a release for it.
Nastya wrote:
If the web-page contains two similar links, then the second link is not opened. For example:
<?php
$I->click('Test Link');
$I->click('Test');
Both steps open the first link.
Actually we can discuss if it's a bug or a feature. But, it's more bug then a feature. This occur due to XPath locators in Mink and BrowserKit libraries. Codeception is a wrapper for Mink and BrowserKit, so there is no reason why it can't be done right. So, Codeception is solving this bug by seraching the strictly matched object at first, and then is trying to find it by more complex XPath locator. I.e., at first it will try to locate <a href="#">Test</a> and if it's not found will match the <a href="#">Test Link</a>.
That's all about 1.1.3
There are pretty much fixes from other contributors. Thanks for anyone sending me pull requests and patches. Here are the changes done by this awesome guys!
From now on it's much easier to define actions in helpers. You can write a method that is not defined yet, and then run new analyze command to append new commands to helper classes. It's quite useful when tester writes a test and needs some new actions to define. When you run
php codecept.phar analyze suitename`
you will be notified on all methods which do not exist in modules, and you will be asked to create them in helpers. Just try!
XPath locators are very powerful but are pretty hard to write and maintain. We decided to provide some useful functions to help writing locators better. Try new Codeception\Util\Locator for that. It will be described in next blogpost. Stay in touch.
As usual, Codeception 1.1.4 can be downloaded from site,
installed via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
In the latest Codeception 1.1.4 new Locator class was introduced. Basically it should simplify your life in writing complex XPath or CSS locators. Right now it has minimal, yet useful functionality.
Locator can combine two locators using OR operand:
<?php
use \Codeception\Util\Locator;
$I->see('Title', Locator::combine('h1','h2','h3'));
?>
This will search for Title text in either h1, h2, or h3 tag. You can also combine CSS selector with XPath locator:
<?php
use \Codeception\Util\Locator;
$I->fillField(Locator::combine('form input[type=text]','//form/textarea[2]'), 'qwerty');
?>
As a result the Locator will produce a mixed XPath value that will be used in fillField action.
Do you often use the TAB key to navigate through the web page? How do your site respond to this navigation?
You could try to match elements by their tab position using tabIndex method of Locator class.
<?php
use \Codeception\Util\Locator;
$I->fillField(Locator::tabIndex(1), 'davert');
$I->fillField(Locator::tabIndex(2) , 'qwerty');
$I->click('Login');
?>
Does the page contain link wo specified URL? Check that easily with href method of Locator class.
<?php
use \Codeception\Util\Locator;
$I->see('Log In', Locator::href('/login.php'));
?>
And that's all folks for today. We are sure the locator class will evolve to simplify writing complex locators. If you have ideas what methods should be added, post them here. Or, which is better, patch this class and send Pull Request to Github.
Codeception is PHP framework for testing web applications in BDD-style. It was started about a year ago, as a plugin for symfony1, to speed up and simplify functional testing inside the framework. But as time passed, Codeception evolved to standalone project, with support of various frameworks and engines. It's built on top of wonderful PHPUnit, but with aim for acceptance, and functional scenario driven tests. In this post we will remind why you may like Codeception and why we feel it's awesome.
Yes, the first reason is PHP. If you are PHP developer it's natural you would like to write tests in PHP. Codeception provides you the best way to do so. Any IDE with code completion and syntax highlighting will help you write tests faster and without stupid syntax mistakes. Usage of PHP inside of tests unleashes the true power and control over the test flow. You can use your application classes or create testing helpers. Also you can get values (with grabbers) from results and use them in your tests. You just control everything. And yep, use everything you like from PHPUnit.
<?php
$I = new TestGuy($scenario);
$I->wantTo('launch missiles from my website');
$I->amOnPage('/launch');
$I->click('Launch Missiles!')
$I->see('Missiles launched');
?>
You know, KISS is our first principle. Even Codeception requires basic knowledge of PHP it narrows testing to using PHP DSL where all actions are defined with user's perspective. Just enter the $I-> and select action from a list and put parameters. That's how a test is written. Also add minimal configuration in YAML format, and installation by downloading a single phar archive. It's really that simple.
You decided to migrate your application from symfony1 to Symfony2, from Kohana to Zend? You decided to test with Selenium inside a real browser? Your tests will run inside chosen the engine, no matters what happen. Codeception using one common syntax for all the backends. Frameworks support allows you to create more complex assertion and check the internals of your application, not only the visible part.
Here comes a QA and says: I need XPath, I need complex selectors, I need to test UI elements strictly. No problems! You can use CSS selectors, XPath locators and even combine them with Locator class. You can also test your SOAP and REST webservices, pragmatical use XMLs (defined in jQuery-like style) and JSONs (as PHP arrays). Despite Codeception tend to be simple, it can be used by QAs creating solid tests automation platform.
<?php
$I->click('New User');
$I->click('#user_1 .user_new');
$I->click('//*[@id = 'user_1']/descendant::a');
$I->see('Title', Locator::combine('h1','h2','h3'));
$I->fillField(Locator::tabIndex(1), 'davert');
$I->see('Log In', Locator::href('/login.php'));
?>
Tests isolation is a problem. Most of testing frameworks puts it's solving to your shoulders. But Codeception tries to fetch your needs and provide Data cleanup from the box. With the Db module you can repopulate database (MySQL, PostgreSQL, ...), after each run, use SQLite (for faster testing), or just run all tests inside transaction (in functional or unit testing). Also Codeception have modules for using and cleaning Memcache and AMQP storages.
And just to mention, the results of tests are readable to non-technical guys. When you export result in HTML you will see the cool colored page with all passed steps described in pure English. Also test results are readable to robots: export result as XML and the CI-server (Jenkins, Bamboo) will use them.
If you are still deciding weather or not to test your application, start doing it now. And Codeception is the right tool for this.
It looks like a good time for the new release! Do you agree?
And yes, there are enough changes to announce Codeception 1.1.5. In this release we concentrated mostly on fixing bugs and improving error reporting. But the most important change, that from now Codeception uses PHPUnit 3.7. This PHPUnit version doesn't have that much BC breaks as previous one, so we hope you will not notice this change.
Some tasty features were added too. But let's start with error reporting.
ERROR with no descriptions, every error have stack trace and description--debug optionsTiger SEO added just another useful module for testing XML-RPC web services.
It requires 'php_xmlrpc' extension and PhpBrowser module to run. With this module you can perform XMLRPC calls and check the responses.
You can review the code at GitHub or read the docs.
grabServiceFromContainer method added to Symfony2 moduleseeInDatabase command with PostgreSQLbuild command is not generating methods with the same names anymorebuild command just after bootstrapThere could be some BC breaks, you should know about.
Before 1.1.5 you could start writing tests without defining a page. Codeception opened the root url "/" by default. So all actions were performed on home page. But opening the page before each test is not the best idea, especially if we test REST/SOAP web service. We just spend time for useless action. So whenever you write acceptance test, please start it with amOnPage action. This change didn't affect the functional tests (for now).
<?php
$I = new WebGuy($scenario);
$I->amOnPage('/'); // required!
?>
Also, we did some changes for 2-steps tests loading, intrudoced in 1.1. At the first stage we read the test contents, in the next we execute it. From now on this stages are isolated, variables from preload will not pass to run. This will require loading of bootstrap file two times. Be prepared for that and optimize your bootstrap file.
As usual, Codeception 1.1.5 can be downloaded from site,
installed via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
Hi, we've decided to start a pro tips post series on Codeception. We hadn't too much time recently, because of the work on our startup Bugira, and the release of community-driven catalog oj Javascript libraries - Jster. You should definitely visit Jster (and add it to bookmarks), as it contains more then 800 javascript libraries for any needs in frontend development. But finally, We can get back to Codeception and tell about it's best usage practices.
You can write pretty complex tests using Codeception. When you have lots of them you may find that changing page UI elements can lead to refactoring all the tests. If you plan to develop a solid automation platform for your web application, consider putting all UI elements into the variables. In this case you can modify your tests pretty easy. If you see like you are creating too much tests, you should think on reorganizing them in a way that can act stable despite of changes in project. It's really hard, features, designs, can constantly change and affect tests. But it's possible to keep your tests stable if you use variables instead of raw values in tests.
Let's say we have an acceptance test tests/acceptance/CreateTaskCept.php:
<?php
$I = new WebGuy($scenario);
$I->wantTo('create todo task');
$I->amOnPage('/tasks');
$I->fillField('New Task','Update a blog');
$I->click('Add');
$I->see('Update a blog', '#tasks');
?>
What if we change the name of buttons and the DOM position of the element where "Update a blog" text should appear?
Let's move this elements to a _bootstrap file and push them into variables.
In tests/acceptance/_bootstrap.php:
<?php
$task_add_button = 'Add';
$task_new_field = 'New Task';
$tasks_list = '#tasks';
?>
And in tests/acceptance/CreateTaskCept.php:
<?php
$I = new WebGuy($scenario);
$I->wantTo('create todo task');
$I->amOnPage('/tasks');
$I->fillField($task_fill_field,'Update a blog');
$I->click($task_add_button);
$I->see('Update a blog', $tasks_list);
?>
As you see replacing values with variables shouldn't affect the test readability while you choose proper names for UI elements. We can also recommend to store user names, passwords, etc in bootstrap too. It will be automatically included on each test run. Use it.
The PageObject is a pattern very popular among QA automation professionals. PageObject allows us to organize variables from a previous tip in more structured way.
Instead of using raw variables we will group them into a class and use them in test and helpers. But classes and constants can't be added to _bootstrap, because bootstrap will be loaded before each test, so it will trigger an error: "Fatal: Cannot redeclare class". Let's deal with that by creating a new PHP file for TodoTask page class:
In tests/acceptance/_todoTaskPage.php:
<?php
class TodoTaskPage {
const URL = '/tasks';
static $add_button = 'Add';
static $new_field = 'New Task';
static $list = '#tasks';
}
?>
Let's add it to tests/acceptance/_bootstrap.php:
<?php
require_once '_todoTaskPage.php';
?>
In this case you won't get lost in where which UI element is located. Because in PageObject pattern the UI element is bound to a page, which we defined by the URL property. And here is the updated test:
<?php
$I = new WebGuy($scenario);
$I->wantTo('create todo task');
$I->amOnPage(TodoTaskPage::URL);
$I->fillField(TodoTaskPage::$new_field,'Update a blog');
$I->click(TodoTaskPage::$add_button);
$I->see('Update a blog', TodoTaskPage::$list);
?>
After this update we have all the UI elements for todo task page kept in one place. Using and IDE you can easily find the right element and insert it into any test of your suite. Despite the raw variables classes and constants are accessible in helpers and unit tests. Also you can improve the page object classes with PHP's OOP power. If you are using PHP 5.4 you can include global UI elements (menus, breadcrumbs) with traits.
Lets create a trait for menu component in tests/acceptance/_menu.php:
<?php
trait GlobalMenu {
public static $global_menu = "//div[@id=menu]";
public static function menuItem($index)
{
return self::$global_menu.'/ul/['.$index.']';
}
}
?>
We add it to tests/acceptance/_bootstrap.php:
<?php
require_once '_menu.php';
require_once '_todoTaskPage.php';
?>
And we are using it in previously declared TodoTaskPage:
<?php
class TodoTaskPage {
use GlobalMenu;
const URL = '/tasks';
static $add_button = 'Add';
static $new_field = 'New Task';
static $list = '#tasks';
}
?>
And now we can use properties and methods of a trait included in class. Thus, TodoTaskPage, as any class that uses GlobalMenu trait can access a menu. Let's write a new test for checking that menu contains a button to create a task.
<?php
$I = new WebGuy($scenario);
$I->wantTo('check task creation link is in a menu');
$I->amOnPage(TodoTaskPage::URL);
$I->see('Create Task', TodoTaskPage::menuItem(3));
?>
If you think on layout components as a traits and pages as classes, you can reorganize your UI elements in a very flexible way. Changes in markup or texts won't affect a tests, as you can easily update all the tests that rely on that element. You can even teach your template developer to update the corresponding PageObject each time she changes template.
Codeception is simple, yet powerful tool for test automation. If you plan to use test automation for the enterprise level projects, it's better to start with proper organization. As we think on architecture before writing the first line of code, we should think on scalable architecture of tests platform. Using PageObject and variables can dramatically improve the reusability (and keep KISS and DRY principles) of your tests.
Today, we will continue covering advanced topics on Codeception. The main power of Codeception is it's modules, there are already plenty of them, even though you might want to extend one of them. Let's say you are using Symfony2 and you want to add additional actions, you actually miss in current module, like dealing with FOSUserBundle: registering, authenticating, etc. You can create a helper and connect with Symfony2 module, get access to dependency injection container and do anything you need there. Sometimes you might want to change the module initialization scripts. This happens if your application configured in a custom way and module doesn't work properly because of it.
In both cases you might want to improve current Symfony2 (or any other module) implementation. That's pretty easy, because we can use just the simple OOP inheritance. You can create your own module Symfony2Helper and inherit it from default Symfony2 module. This module will act as a regular Helper, and should be placed to tests/_helpers dir.
In the next example we will redefine initialization for working with Symfony2 applications located in app/frontend path with Kernel class located in app.
<?php
class Symfony2Helper extends \Codeception\Module\Symfony2
{
// overriding standard initialization
public function _initialize() {
// bootstrap
require_once getcwd().'app/frontend/bootstrap.php.cache';
// kernel class
require_once getcwd().'/FrontendKernel.php';
$this->kernel = new FrontendKernel('test', true);
$this->kernel->boot();
$dispatcher = $this->kernel->getContainer()->get('event_dispatcher');
$dispatcher->addListener('kernel.exception', function ($event) {
throw $event->getException();
});
}
}
?>
Please, refer to the _initialize method implementation to understand the default behavior. To get the idea whether you need to inherit and redeclare methods of module, you need to review it's code. If you see your requirements can't be met by using config options, please override.
By using inheriteance you can redeclare all the methods or initialization hooks you don't like. The API of parent module is pretty clean and even when you use the phar version of Codeception, you can read it's code on GitHub. If you stuck because Codeception module works improperly, you are free to fix that.
And yep, if your improved module is worth sharing with community, submit a patch and it will be added to official distribution. After all, that's how the Open Source works.
Thanks for reading. Use Codeception professionally.
I keep receiving one question. Well, actually two: "What makes Codeception different comparing to Behat". And the next one: "Why can't I write Codeception tests in human language like Behat does". I think the time has come to answer this questions.
As you know, the Behat project is not only a tool but a methodology. The Behavior Driven Development concept requires that the User Stories to be written, and then executed as a test. Behat is a right tool for teams who strictly follow the BDD methodology. But what if you don't? For what in the world you need tests written in plain English?
If you write a story like this, using Behat and MinkContext for example,
Given I am on "/product/1"
When I click "Purchase"
And I fill in "name" with "Michael"
And I fill in "credit" with "321123123"
And I click "Order"
Then I should see "The product was purchased!"
you actually write test, and not a story. Because the feature you describe won't change If you rename field "credit" to "credit card", but the test will fail. You may change the text "The product was purchased" to "iPhone5 was purchased. Thank you!" and that will make test fail too. So you will rewrite the user story every time you change every detail that may affect passing test. In this case the manager who wrote this spec will debug and update user story to make the test pass.
And so your manager becomes tester. His role is now not only to deliver specifications to team but also to make this specifications written as tests and make them pass.
But what If you want one additional step to the scenario?
Given I am "/product/1"
When I click "Purchase"
Then I should see "1 product" in the bin
For this step see "1 product" in the bin you should write a custom step. If only your manager knew PHP for it! Ideally to become manager + tester + PHP guru. But no, manager needs to ask your developer to write the necessary step. Thus, already two people are writing the test. And one of them knows PHP. And when you will hire a QA will you require a knowledge of PHP? Well, yep. Thus because you don't want to disturb your PHP devs and assign them additional tasks.
When your product growths your tests becomes more and more complex. And you need to keep them updated for each change. When you use the plain English text, you don't have a control over tests. When your form don't have a label you need to write custom step instead of I fill in, because it's actually wrong to use CSS or XPath selectors inside a Behat feature. It's not plain English text anymore with CSS. You need PHP developers to create additional steps.
Why Codeception is better testing tool? Well, just because it is a testing tool at first. Spend a day, to teach your manager/tester/qa PHP DSL, install a Netbeans or PHPStorm (or any other IDE), and start writing tests. Even when tests looks similarly to Behat features they give more power and control over the process.
<?php
$I = new WebGuy($scenario);
$I->amOnPage('/product/1');
$I->click('Purchase');
$I->fillField('name', 'Michael');
$I->fillField('credit', '321123123');
$I->click('Order');
$I->see('The product was purchased!');
This test in the process of evolution can be transformed into something more complex. You can use CSS and XPath everywhere, so when you change the "Order" button with an image, you can use it's CSS and quickly update a test to make it pass. Also, you can move repeatable elements into variables and classes and make a test that looks like this:
<?php
$I = new WebGuy($scenario);
$I->amOnPage(ProductPage::URL);
$I->click('#purchase');
$I->fillField('name', $user_name);
$I->fillField('credit', $user_credit);
$I->click('img a#order');
$I->see(ProductPage::$successMessage);
Just the same scenario. Well it's a bit harder to read, as we added CSS selectors, but as you see this test pretty much more flexible. It can be easily refactored and improved without writing any custom method to helper.
Don't fall into a marketing trap. You will find yourself writing tests two times: as a feature in plain English and in code with PHP.
It's better to have one person who can take a full control over test automation then, delegate some tasks to developers, some tasks to managers. If you are developer and you work on your own project. Why PHP is not suitable for you? Why do you want to write code 2 times: once in feature with Gherkin and second time in Context. Is it KISS? Is it DRY? I don't think so.
Will Codeception support plain text test scenarios? Really, I thought on that. But I don't want to put the limits. Using plain text makes impossible to use variables, loops, grabbers, and thus use PageObject pattern. Which is very important for solid and concrete test automation platform.
Behat is great BDD tool and it's author @everzet also states: don't use it for functional testing. Choose the right tool for job.
Disclaimer: I'm not very good in theory, I'm very practical guy. I won't refer you to any published books or methodologies. But If you want an authority... Well, David Heinemeier Hansson (the creator of Rails) wrote in his blog: 1"Don’t use Cucumber unless you live in the magic kingdom of non-programmers-writing-tests". And Behat is Cucumber for PHP. DHH is known for his dislike to popular BDD tools like RSpec or Cucumber. But he is very pragmatic and very scrupulous in testing.
We'd like to announce new Codeception 1.5 major release. This time our improvements are CodeCoverage and Remote CodeCoverage added. These features allows you to collect code coverage reports for all your tests: unit, functional, and acceptance and merge them together. So now you can review what parts of your applications are tested and which are not even for Selenium and PhpBrowser tests which are executed on a webserver.
Read more in the new Guides chapter.
There is no magic in local codecoverage. XDebug and PHP_CodeCoverage libraries do their job. The tricky thing is remote codecoverage. We attach small script into application's front controller. When a special header is sent this script starts to collect coverage information. And in the end of tests, this data is merged, serialized and sent back to Codeception. So you can test and collect coverage report even on staging servers in real environment.
Thanks to tiger-seo for codecoverage feature. He did a great job developing a remote script c3.php which is a unique in it's way.
But back to Codeception. As you may've noticed our website is updated too. Documentation was improved, search was added, and nice Quickstart page added too. So if you didn't try Codeception yet, it's very easy to start now. In only 6 steps.
Two useful modules were introduced by judgedim. We have support of MongoDb and Redis now. They both can clean up your storages between tests and Mongo can perform checks in your collections. So If you are working with NoSQL databases, you should try them in your tests. If you use different NoSQL databases, please submit your patches, and they will be included in next release.
Now you can execute a test by providing relative path to test, like.
php codecept.phar tests/acceptance/SignInCept.php
This small tweak imprioves user experience for *nix users as they can use autocompletion when running a test.
Also you can run test from one specific directory, i.e. match a group of tests:
php codecept.phar tests/acceptance/admin
Composer package is works again. It's really hard to follow the stability in the world of constant changes, so we recommend use of phar for testing, just because it's prepackaged and always runs as expected. But if you use Composer it's easy to add Codeception to your vendors and receive all new updates with new release. Don't forget to mark @stable Codeception version.
As usual, Codeception 1.5.0 can be downloaded from site,
installed via PEAR
$ pear install codeception/Codeception
or via Composer
$ php composer.phar update
As you may've noticed all that guys who took part in developing Codeception are now shown on every page of this site. Thn this way we say thank for all our contributors and all guys who support this project, for all companies that adopt Codeception in their workflow.
