Conventions¶

• Tests should be in the following directories:

  • {app_name}/tests - application tests
  • {app_name}/mojits/{mojit_name}/tests - mojit tests
  • {app_name}/autoload/{yui_module}/tests - tests for application-level YUI modules
  • {app_name}/mojits/{mojit_name}/autoload/{yui_module}/tests - tests for mojit-level YUI modules

• Syntax for the name of the test file: {yui_module}.{affinity}-tests.js

  For example, the name of the unit test YUI module for the HelloMojit mojit with the server affinity would be HelloMojit-tests.server.js.

• The unit test YUI module should include the target module and the mojito-test module in the requires array. The requires array includes the mojito-test module and the target module HelloMojit:

  { requires: [ 'mojito-test', 'HelloMojit' ] }
  

Framework Tests¶

After you have installed Mojito, you should run the framework test to confirm that Mojito installed correctly and that Node.js has been given permission to access the file system.

To test the Mojito framework, run the following:

$ mojito test

Application Tests¶

Running applications tests is much like running the framework tests above. The following command runs tests for all of the mojits of a Mojito application.

$ mojito test app {path-to-app}/{application-name}

To run one specific test in your application, use the following where [test-name] is either the YUI module or the module to be tested.

$ mojito test app {path-to-app}/{application-name} [test-name]

Mojit Tests¶

You create unit tests for your mojits and execute them also using the mojito command. Mojit tests must require (included in the YUI require array) the module undergoing testing and the Mojito Test module mojito-test. For example, if the Foo module was being tested, the requires array would include the Foo and mojit-test modules as seen here: requires: [ 'Foo', 'mojit-test']

By default, Mojito uses the YUI Test framework for the test harness and assertion functions. Each mojit test will be executed within a YUI instance along with its required dependencies, so you can be assured to only have properly scoped values.

Testing Standards¶

To use the Mojito test harness, you are required to name files and testing modules according to certain rules. The name of the test file must have the same affinity as the file being tested and have the string -tests appended to the affinity. For example, the mojit controller with the common affinity would be controller.common.js, so the name of the test file must be controller.common-tests.js.

The controller.common.js below requires the Foo module.

YUI.add('Foo', function(Y) {
  ...
});

To test the Foo, module, the the test file controller.common-tests.js would require the Foo-tests module as seen below.

YUI.add('Foo-tests', function(Y) {
  ...
}, 'VERSION', {requires: ['mojito-test', 'Foo']});

Binder Tests¶

You can create multiple binder tests and place them in the tests/binders directory. For example, if your binder is binders/index.js, the test file would be tests/binders/index.common-test.js. Notice that the affinity is common, which can be used for binders on the client or server and is also the default binder test file.

YUI.add('FooBinderIndex', function(Y, NAME) {
  Y.namespace('mojito.binders')[NAME] = {
    init: function(mojitProxy) {
      this.mojitProxy = mojitProxy;
    },
    bind: function(node) {
      this.node = node;
      var nodeId = node.get('id');
      var binderId = this.mojitProxy._viewId;
      Y.log(nodeId + ' node bound', 'debug', NAME);
      if (nodeId !== binderId) {
        throw new Error("bad node binding to binder!");
      }
      this.node.append("<p>" + nodeId + " bound</p>");
    },
    _updateId: function(msg) {
      var nodeId = this.node.get('id');
      msg = msg || 'bound';
      this.node.one("p").set('innerHTML', nodeId + ' ' + msg);
    },
    handleClick: function(evt) {
      this.node.one('div').set('innerHTML', "clicked on " + new Date());
    }
  };
}, '0.0.1', {requires: []});

YUI.add('FooBinderIndex-tests', function(Y, NAME) {
  var suite = new YUITest.TestSuite(NAME),
  binder, A = YUITest.Assert;
  suite.add(new YUITest.TestCase({
    name: 'Foo binder index tests',
    setUp: function() {
      binder = Y.mojito.binders.FooBinderIndex;
    },
    tearDown: function() {
      binder = null;
    },
    'test update id': function() {
      var node = Y.Node.create("<div id='guid123'></div>");
      binder.init({
        _guid: 'guid123'
      });
      binder.bind(node);
      binder._updateId('hello');
      var content = node.one('p').getContent();
      Y.log(content);
      A.areSame(content, 'guid123 hello', 'the node was not updated');
    }
  }));
  YUITest.TestRunner.add(suite);
}, '0.0.1', {requires: ['mojito-test', 'node', 'FooBinderIndex']});

Controller Tests¶

A mojit can have one or more controllers that have different affinities. For each controller, you can create create a test controller with the same affinity or use controller.common-tests.js, which tests controllers with any affinity. For example, controller.server.js can be tested with controller.server-tests.js or controller.common-tests.js.

YUI.add('Foo', function(Y, NAME) {
  Y.namespace('mojito.controllers')[NAME] = {
    init: function(mojitSpec) {
      this.spec = mojitSpec;
    },
    index: function(ac) {
      ac.done();
    }
  };
}, '0.0.1', {requires: []});

YUI.add('Foo-tests', function(Y, NAME) {
  var suite = new YUITest.TestSuite(NAME),
  controller = null,
  A = YUITest.Assert;
  suite.add(new YUITest.TestCase({
    name: 'Foo tests',
    setUp: function() {
      controller = Y.mojito.controller;
    },
    tearDown: function() {
      controller = null;
    },
    'test mojit': function() {
      var ac, doneCalled = false;
      A.isNotNull(controller);
      A.isFunction(controller.index);
      ac = {
        done: function(data) {
          doneCalled = true;
          A.isUndefined(data);
        }
      };
      controller.index(ac);
      A.isTrue(compCalled);
    }
  }));
  YUITest.TestRunner.add(suite);
}, '0.0.1', {requires: ['mojito-test', 'Foo']});

Testing with the MockActionContext Object¶

The mojito-test YUI module allows you to create the mock object MockActionContext to test without dependencies. Using the MockActionContext object, you can easily build an ActionContext for your controller, addon, and model tests. To learn more information about using YUI to create mock objects, see YUI Test Standalone Library: Mock Objects.

var ac = new Y.mojito.MockActionContext();
ac.expect(
  {
    method: 'done',
    args: [YUITest.Mock.Value.Object],
    run: function(data) {
      YUITest.ObjectAssert.areEqual({ just: 'testing' });
    }
  }
);
Y.mojito.controller.actionUnderTest(ac);
ac.verify();

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

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

Y.mojito.controller.actionUnderTest(ac);

ac.verify();

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']
  }
);

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']
  });

var ac = new Y.mojito.MockActionContext({
  addons: ['intl', 'assets']
});
ac.intl.expect({
  method: 'lang',
  args: ['UPDATING'],
  returns: 'updating, yo'
});

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

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

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'});
    }
  }
);

Model Tests¶

Model tests are largely the same as controller tests, except there can be many of them. The model tests are placed in the tests/models directory. You can create multiple model tests or use models.common-tests.js to test both server and client models.

YUI.add('FooModel', function(Y, NAME) {
  Y.namespace('mojito.models')[NAME] = {
    getData: function(callback) {
      callback({some:'data'});
    }
  };
}, '0.0.1', {requires: []});

YUI.add('FooModel-tests', function(Y, NAME) {
  var suite = new YUITest.TestSuite(NAME),
  model = null,
  A = YUITest.Assert;
  suite.add(new YUITest.TestCase({
    name: 'Foo model tests',
    setUp: function() {
      model = Y.mojito.models.Layout;
    },
    tearDown: function() {
      model = null;
    },
    'test mojit model': function() {
      A.isNotNull(model);
      A.isFunction(model.getData);
    }
  }));
  YUITest.TestRunner.add(suite);
}, '0.0.1', {requires: ['mojito-test', 'FooModel']});

Functional/Unit Tests¶

Mojito comes with functional tests that you can run with the npm module Arrow, a testing framework that fuses together JavaScript, Node.js, PhantomJS, and Selenium. Arrow lets you write tests in YUI Test that can be executed on the client or server. You can also write your own functional/unit tests with Arrow. Mojito recommends that contributors write Arrow functional/unit tests for their code to accelerate the process of merging pull requests.

The following sections show you how to set up your environment and run the unit and functional tests that come with Mojito. In the future, we will also provide you with instructions for writing Arrow tests for your code contributions.