Bob's Blog

In the previous article in this series, we created a very simple unit test to make sure the testing platform was working. In this one we'll extend that test to do some actual testing on a User class.

This article assumes that you have successfully installed Codeception (which installs PhpUnit) with Composer and created the unit test described in the previous articles.

A Real Test

In the build directory, give this command:

codecept generate:test unit T1_UserConstructor

Now copy the code below into the new T1_UserConstructorTest.php file.

Our first test (in the previous article) just showed that the unit test platform was working. In this article, we'll create a minimal User class called User1.class.php (but not yet). First, we'll create some tests we want the class to pass. Let's add a test of our class's constructor. We want the constructor to create a User1 object with empty fields when called with no parameters (arguments) and a User1 object with fields filled from the parameters. Here is the new test file code for the T1_UserConstructorTest.php file (the new code is below the _before() and _after() methods):

 <?php

class T1_UserConstructorTest extends \Codeception\Test\Unit {
    /**
     * @var \UnitTester
     */
    protected $tester;

    protected function _before() {
        require_once 'c:/xampp/htdocs/addons/assets/mycomponents/testingproject/core/model/user1.class.php';
    }

    protected function _after() {
    }

    /* Tests */
    public function testWorking() {
        assertTrue(true);
    }

    public function testConstructorWithParams() {
        $user = new User1(array(
            'username' => 'BobRay',
            'email' => 'bobray@hotmail.com',
            'phone' => '651-423-1548'
        ));
        assertInstanceOf('User1', $user);
        assertEquals('BobRay', $user->get('username'));
        assertEquals('bobray@hotmail.com', $user->get('email'));
        assertEquals('651-423-1548', $user->get('phone'));
    }

    public function testConstructorNoParams() {
        $user = new User1();
        assertInstanceOf('User1', $user);
        assertEquals('', $user->get('username'));
        assertEquals('', $user->get('email'));
        assertEquals('', $user->get('phone'));
    }
}
 

Save the file and run the test again (most terminals will let you repeat that last command if you press the up arrow). The test code is available from GitHub here.

codecept run unit T1_UserConstructorTest

You should see this:

[Error] Class 'User1' not found

That makes sense because we haven't created our User1 class yet.

The User Class File

Create a user1.class.php file somewhere. Typically it will be outside the _build directory. You could, for example, create a classes directory at the same level as the _build directory and put the file there. In my example (and at the GitHub repository), it's in the core/model/ directory.

Use this code in the user1.class.php file:

<?php
    class User {
        protected $fields = array(
            'username' => '',
            'email' => '',
            'phone' => ''
        );

    /* Note that there are two underscores before the word "construct" */
    function __construct($properties = array()){
        if (!empty($properties)) {
            foreach ($properties as $key => $value) {
                if (array_key_exists($key, $this->fields )) {
                    $this->set($key, $value);
                }
            }
        }
    }

    public function set($fieldName, $value) {
        $this->fields[$fieldName] = $value;
    }
    public function get($fieldName) {
        if (array_key_exists($fieldName, $this->fields)) {
            return $this->fields[$fieldName];
        } else {
            return '';
        }
    }

    public function save() {
        return true;
    }
}

Save the class file, then add this code to the _before() function (correct the path) in the test file we created at the beginning of this article:

require_once 'path/to/user/file/user1.class.php';

Run the test again.

codecept run unit T1_UserConstructorTest

You should see this:

OK (3 tests, 11 assertions)

As we said earlier, rather than adding the code to the _before() function, you could add it to a _bootstrap.php file. You'd add this to the unit.suite.yml file:

settings:
    bootstrap: _bootstrap.php

(or this for later versions of Codeception):

bootstrap: _bootstrap.php

Then you could add the require_once statement to the _build/tests/unit/_bootstrap.php file (creating it if necessary) and add the require_once line to that file. Since you're likely to have other tests that don't need the User1 class file, it makes more sense to put the line in the _before() method.

You should already have the _build/tests/unit/_bootstrap.php file, if you've been following this series. If it's there, verify that it contains an opening PHP tag and the following lines (correct the paths). If not, create it and add the PHP tag and these lines:

require_once 'c:/xampp/htdocs/addons/vendor/autoload.php';
require_once 'c:/xampp/htdocs/addons/vendor/phpunit/phpunit/src/Framework/Assert/Functions.php';

These includes will be necessary for all our tests, so it's more convenient to load them in the _bootstrap.php file rather than having to remember to include them in the _before() method of every test.

Running Tests from the Command Line

Use the command-line method for running tests. It should run reliably for our early examples with no configuration necessary beyond the default files generated by Codeception. Later, you can try running the tests from inside your code editor if it supports that feature. Some people run all their tests from the command line.

As we saw in the previous article, from the command line, while in the directory above the tests directory (the _build directory in our example), you can run run all test files in all suites, all test files in a particular suite, specific test files (codecept run unit UserTest), or a single method (function) in one of the test files.

Run Commands

We covered this in the last article, but here's a review of the Codeception run command. It's assumed that you are in the _build directory for all these commands:

• Run all test files in all suites: codecept run
• Run all test files in a single suite: codecept run unit
• Run a single test file in a suite: codecept run unit T1_UserConstructorTest
• Run all test files in two suites: codecept run unit,integration
• Run a single method/function in one test file: codecept run unit T1_UserTest:testConstructor

Codeception runs the last command above as if it has a wildcard at the end of the method name. So if two of the methods in your UserTest file are called testConstructorWithParams() and testConstructorNoParams(), the last command above will run both of them. codecept run unit UserTest:testCon would also work.

class MyClass extends PHPUnit\Framework\TestCase {}

phpunit --filter methodName path/to/file.php

Coming Up

We'll get back to enhancing and testing our User class, but in the next article, we'll see how to run Codeception tests in PhpStorm.

For more information on how to use MODX to create a web site, see my web site Bob's Guides, or better yet, buy my book: MODX: The Official Guide.

Looking for high-quality, MODX-friendly hosting? As of May 2016, Bob's Guides is hosted at A2 hosting. (More information in the box below.)