simpletest_example.test

<?php


/**
 * @file
 * An example of simpletest tests to accompany the tutorial at
 * http://drupal.org/node/890654.
 */

/**
 * The SimpleTestExampleTestCase is a functional test case, meaning that it
 * actually exercises a particular sequence of actions through the web UI.
 * The majority of core test cases are done this way, but the SimpleTest suite
 * also provides unit tests as demonstrated in the unit test case example later
 * in this file.
 *
 * Functional test cases are far slower to execute than unit test cases because
 * they require a complete Drupal install to be done for each test.
 *
 * @see DrupalWebTestCase
 * @see SimpleTestUnitTestExampleTestCase
 *
 * @ingroup simpletest_example
 */
class SimpleTestExampleTestCase extends DrupalWebTestCase {
    protected $privilegedUser;
    
    /**
     * Give display information to the SimpleTest system.
     *
     * getInfo() returns a keyed array of information for SimpleTest to show.
     *
     * It's a good idea to organize your tests consistently using the 'group'
     * key.
     */
    public static function getInfo() {
        return array(
            'name' => 'SimpleTest Example',
            'description' => 'Ensure that the simpletest_example content type provided functions properly.',
            'group' => 'Examples',
        );
    }
    
    /**
     * Set up the test environment.
     *
     * This method is called once per test method, before the test is executed.
     * It gives you a chance to control the setup of the test environment.
     *
     * If you need a different test environment, then you should create another
     * test class which overloads DrupalWebTestCase::setUp() differently.
     *
     * @see DrupalWebTestCase::setUp()
     */
    public function setUp() {
        // We call parent::setUp() with the list of modules we want to enable.
        // This can be an array or just a list of arguments.
        parent::setUp('simpletest_example');
        // Create and log in our user. The user has the arbitrary privilege
        // 'extra special edit any simpletest_example' which is provided by
        // our module to grant access.
        $this->privilegedUser = $this->drupalCreateUser(array(
            'create simpletest_example content',
            'extra special edit any simpletest_example',
        ));
        $this->drupalLogin($this->privilegedUser);
    }
    
    /**
     * Create a simpletest_example node using the node form.
     */
    public function testSimpleTestExampleCreate() {
        // Create node to edit.
        $edit = array();
        $edit['title'] = $this->randomName(8);
        $edit["body[und][0][value]"] = $this->randomName(16);
        $this->drupalPost('node/add/simpletest-example', $edit, t('Save'));
        $this->assertText(t('SimpleTest Example Node Type @title has been created.', array(
            '@title' => $edit['title'],
        )));
    }
    
    /**
     * Create a simpletest_example node and then see if our user can edit it.
     */
    public function testSimpleTestExampleEdit() {
        $settings = array(
            'type' => 'simpletest_example',
            'title' => $this->randomName(32),
            'body' => array(
                LANGUAGE_NONE => array(
                    array(
                        $this->randomName(64),
                    ),
                ),
            ),
        );
        $node = $this->drupalCreateNode($settings);
        // For debugging, we might output the node structure with $this->verbose()
        // It would only be output if the testing settings had 'verbose' set.
        $this->verbose('Node created: ' . var_export($node, TRUE));
        // We'll run this test normally, but not on the testbot, as it would
        // indicate that the examples module was failing tests.
        if (!$this->runningOnTestbot()) {
            // The debug() statement will output information into the test results.
            // It can also be used in Drupal 7 anywhere in code and will come out
            // as a drupal_set_message().
            debug('We are not running on the PIFR testing server, so will go ahead and catch the failure.');
            $this->drupalGet("node/{$node->nid}/edit");
            // Make sure we don't get a 401 unauthorized response:
            $this->assertResponse(200, 'User is allowed to edit the content.');
            // Looking for title text in the page to determine whether we were
            // successful opening edit form.
            $this->assertText(t("@title", array(
                '@title' => $settings['title'],
            )), "Found title in edit form");
        }
    }
    
    /**
     * Detect if we're running on PIFR testbot.
     *
     * Skip intentional failure in that case. It happens that on the testbot the
     * site under test is in a directory named 'checkout' or 'site_under_test'.
     *
     * @return bool
     *   TRUE if running on testbot.
     */
    public function runningOnTestbot() {
        // @todo: Add this line back once the testbot variable is available.
        // https://www.drupal.org/node/2565181
        // return env('DRUPALCI');
        return TRUE;
    }

}

/**
 * Although most core test cases are based on DrupalWebTestCase and are
 * functional tests (exercising the web UI) we also have DrupalUnitTestCase,
 * which executes much faster because a Drupal install does not have to be
 * one. No environment is provided to a test case based on DrupalUnitTestCase;
 * it must be entirely self-contained.
 *
 * @see DrupalUnitTestCase
 *
 * @ingroup simpletest_example
 */
class SimpleTestUnitTestExampleTestCase extends DrupalUnitTestCase {
    
    /**
     * {@inheritdoc}
     */
    public static function getInfo() {
        return array(
            'name' => 'SimpleTest Example unit tests',
            'description' => 'Test that simpletest_example_empty_mysql_date works properly.',
            'group' => 'Examples',
        );
    }
    
    /**
     * Set up the test environment.
     *
     * Note that we use drupal_load() instead of passing our module dependency
     * to parent::setUp(). That's because we're using DrupalUnitTestCase, and
     * thus we don't want to install the module, only load it's code.
     *
     * Also, DrupalUnitTestCase can't actually install modules. This is by
     * design.
     */
    public function setUp() {
        drupal_load('module', 'simpletest_example');
        parent::setUp();
    }
    
    /**
     * Test simpletest_example_empty_mysql_date().
     *
     * Note that no environment is provided; we're just testing the correct
     * behavior of a function when passed specific arguments.
     */
    public function testSimpleTestUnitTestExampleFunction() {
        $result = simpletest_example_empty_mysql_date(NULL);
        // Note that test assertion messages should never be translated, so
        // this string is not wrapped in t().
        $message = 'A NULL value should return TRUE.';
        $this->assertTrue($result, $message);
        $result = simpletest_example_empty_mysql_date('');
        $message = 'An empty string should return TRUE.';
        $this->assertTrue($result, $message);
        $result = simpletest_example_empty_mysql_date('0000-00-00');
        $message = 'An "empty" MySQL DATE should return TRUE.';
        $this->assertTrue($result, $message);
        $result = simpletest_example_empty_mysql_date(date('Y-m-d'));
        $message = 'A valid date should return FALSE.';
        $this->assertFalse($result, $message);
    }

}

/**
 * SimpleTestExampleMockModuleTestCase allows us to demonstrate how you can
 * use a mock module to aid in functional testing in Drupal.
 *
 * If you have some functionality that's not intrinsic to the code under test,
 * you can add a special mock module that only gets installed during test
 * time. This allows you to implement APIs created by your module, or otherwise
 * exercise the code in question.
 *
 * This test case class is very similar to SimpleTestExampleTestCase. The main
 * difference is that we enable the simpletest_example_test module in the
 * setUp() method. Then we can test for behaviors provided by that module.
 *
 * @see SimpleTestExampleTestCase
 *
 * @ingroup simpletest_example
 */
class SimpleTestExampleMockModuleTestCase extends DrupalWebTestCase {
    
    /**
     * Give display information to the SimpleTest system.
     *
     * getInfo() returns a keyed array of information for SimpleTest to show.
     *
     * It's a good idea to organize your tests consistently using the 'group'
     * key.
     */
    public static function getInfo() {
        return array(
            'name' => 'SimpleTest Mock Module Example',
            'description' => "Ensure that we can modify SimpleTest Example's content types.",
            'group' => 'Examples',
        );
    }
    
    /**
     * Set up the test environment.
     *
     * Note that we're enabling both the simpletest_example and
     * simpletest_example_test modules.
     */
    public function setUp() {
        // We call parent::setUp() with the list of modules we want to enable.
        parent::setUp('simpletest_example', 'simpletest_example_test');
    }
    
    /**
     * Test modifications made by our mock module.
     *
     * We create a simpletest_example node and then see if our submodule
     * operated on it.
     */
    public function testSimpleTestExampleMockModule() {
        // Create a user.
        $test_user = $this->drupalCreateUser(array(
            'access content',
        ));
        // Log them in.
        $this->drupalLogin($test_user);
        // Set up some content.
        $settings = array(
            'type' => 'simpletest_example',
            'title' => $this->randomName(32),
            'body' => array(
                LANGUAGE_NONE => array(
                    array(
                        $this->randomName(64),
                    ),
                ),
            ),
        );
        // Create the content node.
        $node = $this->drupalCreateNode($settings);
        // View the node.
        $this->drupalGet("node/{$node->nid}");
        // Check that our module did it's thing.
        $this->assertText(t('The test module did its thing.'), "Found evidence of test module.");
    }

}