Creating the MockActionContext Object¶

To mock the ActionContext, the mojito-test YUI module provides the MockActionContext constructor that returns a mocked ActionContext as shown below:

var ac = new Y.mojito.MockActionContext();

Setting Test Expectations¶

To test with the MockActionContext object, you use the expect method and pass it an expectation object containing the properties method, args, and run. These properties, in turn, contain the controller method to test, the function parameters, and the test function.

In the code snippet below, the expect method creates a test for the controller method done, using the YUITest module to perform an assertion on the function’s return value.

ac.expect({
  method: 'done',
  args: [YUITest.Mock.Value.Object],
  run: function(data) {
    YUITest.ObjectAssert.areEqual({ just: 'testing' });
  }
});

Configuring Mojito to Test MockActionContext Object¶

To configure Mojito to use your MockActionContext object to run test, use the following, where {actionUnderTest} is the action you are testing.

Y.mojito.controller.{actionUnderTest}(ac);

If the {actionUnderTest} function fails to call the done function, calls it more than one time, or calls it with the wrong parameters, the test will fail.

ac.verify();

Passing Multiple expectation Objects¶

You can pass many expectation objects to the expect method:

ac.assets.expect({
  method: 'preLoadImages',
  args: [YUITest.Mock.Value.Object],
  run: function(arr) {
    OA.areEqual(['thepath','thepath'], arr);
  },
  callCount: 1
  },
  {
    method: 'getUrl',
    args: [YUITest.Mock.Value.String],
    returns: 'thepath',
    callCount: 3
  },
  {
    method: 'addCss',
    args: ['thepath']
  }
);

Chaining expect Methods¶

You can also chain expect methods:

ac.assets.expect(
  {
    method: 'preLoadImages',
    args: [YUITest.Mock.Value.Object],
    run: function(arr) {
      OA.areEqual(['thepath','thepath'], arr);
    },
    callCount: 1
  }).expect({
    method: 'getUrl',
    args: [YUITest.Mock.Value.String],
    returns: 'thepath',
    callCount: 3
  }).expect({
    method: 'addCss',
    args: ['thepath']
  });

Mocking Custom Addons¶

To create a custom addon that contains functions within a property, you might have an addon that is used in the following way:

ac.customAddon.params.get('key');

To test the addon, you pass the addons array with a list of the addons you want to test to the MockActionContext constructor as seen below:

var ac = new Y.mojito.MockActionContext(
  {
    addons: ['customAddon'],
    extras: { customAddon: 'params'}
  }
);

This will give you a mock object at ac.customAddon.params from which you can call expect.

Mocking Models¶

To test models with the MockActionContext object, you pass the models array with the model YUI modules as is done with addons:

var ac = new Y.mojito.MockActionContext(
  {
    addons: ['intl', 'params'],
    models: ['foo']
  }
);
ac.models.foo.expect(
  {
    method: 'getData',
    args: [YUITest.Mock.Value.Object,
    YUITest.Mock.Value.Function],
    run: function(prms, cb) {
      cb(null, {my: 'data'});
    }
  }
);

controller.server.js¶

YUI.add('myMojit', function(Y, NAME) {
  Y.namespace('mojito.controllers')[NAME] = {
    index: function(ac) {
        ac.done({
           status: 'Mojito is working.',
        });
      }
    };
}, '0.0.1', {requires: ['mojito', 'myMojitModelFoo']});

controller.server-tests.js¶

YUI.add('tester-tests', function(Y) {
  var suite = new YUITest.TestSuite('tester-tests'),
      controller = null,
      A = YUITest.Assert;

  suite.add(new YUITest.TestCase({
    name: 'tester user tests',
    setUp: function() {
      controller = Y.mojito.controllers.tester;
    },
    tearDown: function() {
      controller = null;
    },
    'test mojit': function() {
      var ac = new Y.mojito.MockActionContext({});
      A.isNotNull(controller);
      A.isFunction(controller.index);
      ac.expect({
        method: 'done',
        args: [YUITest.Mock.Value.Object],
        callCount: 1,
        run: function(data){
          YUITest.ObjectAssert.areEqual({ status: 'Mojito is working.' },data);
        }
      });
      controller.index(ac);
      ac.verify();
    }
  }));
  YUITest.TestRunner.add(suite);
}, '0.0.1', {requires: ['mojito-test', 'myMojit']});

Required Software¶

• Java
• Git
• Firefox v20

Optional Software¶

To run functional tests in a browser, you need to install the Selenium Server.

Setting Up¶

1. Clone the Mojito repository.

   $ git clone https://github.com/yahoo/mojito.git

2. Change to the mojito directory.

3. Install the Mojito dependencies:

$ npm install

Running Tests with PhantomJS¶

By default, Mojito uses the npm package phantomjs for running tests. You can use npm to run functional and unit tests.

For more control over the running tests, such as running one test or specifying a different location to write test results, use the wrapper script run.js that comes with Mojito.

Running Tests with Selenium¶

To run tests in a browser, you need the Selenium Server and browser drivers. Selenium Server comes with a driver for Firefox, so do not need to install the Firefox driver. To run tests in Chrome and other browsers, you will need to install the appropriate drivers. In the steps below, we’ll just be using the default browser Firefox.

1. Install Selenium:

   1. Download the Selenium v2.31.0 JAR executable.

   2. Start the Selenium server:

      $ java -jar path/to/selenium-server-standalone-2.31.0.jar

   3. Confirm Selenium is running by going to the following URL:

   http://localhost:4444/wd/hub/static/resource/hub.html

   1. Shut down the Selenium server with Ctrl-C command.

      Warning

      If you are not using Firefox v20 and the Selenium Standalone Server v2.31.0, you may run into backward compatibility issues. Please see the Platforms Supported by Selenium to learn what Selenium and browser versions are compatible.

2. Change to the mojito/tests directory.

3. Start the Selenium server in the background.

   $ java -jar path/to/selenium-server.jar &

4. Run the unit tests for the framework and client. As we mentioned before, the default browser is Firefox. To specify Chrome, you would add the option --browser chrome.

   $ ./run.js test -u --path unit --group fw,client,server --reuseSession

5. You can also run all the functional tests with the below command.

   $ ./run.js test -f --path func --port 4000

   The functional tests may take some time to complete, so you may want to terminate the tests with Ctl-C. Also, you do not need to specify the port with --port, but the command above does to show you the option.

6. To run individual unit and functional tests, you pass the test descriptor to run.js.

   $ ./run.js test -f --path func --descriptor examples/newsboxes/newsboxes_descriptor.json --port 4000 --reuseSession

   The command above runs the functional test for the newsboxes application. The --path option indicates that the path to the test descriptor is located in the func directory: func/examples/newsboxes/newsboxes_descriptor.json

Test Results¶

Test results are written in both XML and JSON. You can specify the location to write test results or use the default location. In the following sections, we’ll look at the default locations and the way to specify the location for unit and functional tests.