CSC/ECE 517 Fall 2014/ch1b 26 sa

Jasmine

Jasmine is an open source Behavior Driven Development (BDD) based testing framework for JavaScript. It is maintained by Pivotal Labs and is available on GitHub under the MIT license. Jasmine allows tests to be written independent of the DOM or other JavaScript frameworks. Jasmine can be run in a browser, or headless without a browser by integrating with other frameworks such as Rhino, Envy, or the Jasmine-headless-webkit library.

It can be used in the Rails framework. Jasmine ships as a Rubygem and leverages familiar rake tasks and generators to automate common workflows. Jasmine is heavily influenced by other unit testing frameworks, such as ScrewUnit, JSSpec, JSpec, and RSpec; and has syntax very similar to RSpec.

Background

The Jasmine framework was developed since developers to address certain specific concerns in existing testing frameworks <ref name="Background">https://github.com/pivotal/jasmine/wiki/Background</ref>

• Many frameworks only work from within a browser.
• Many don't support testing asynchronous code like event callbacks.
• Some have syntax that's hard for JS developers or IDEs to understand.

Design Principles

The Jasmine developer community believes that a good JavaScripttesting framework must follow these principles. <ref name="Background"/>

• should not be tied to any browser, framework, platform, or host language.
• should have idiomatic and unsurprising syntax.
• should work anywhere JavaScriptcan run, including browsers, servers, phones, etc.
• shouldn't intrude in your application's territory (e.g. by cluttering the global namespace).
• should play well with IDEs (e.g. test code should pass static analysis).

Goals

The Jasmine framework is written with the objective of meeting these goals.<ref name="Background"/>

• it should encourage good testing practices.
• it should integrate easily with continuous build systems.
• it should be simple to get started with.

Usage

Jasmine aims to be easy to read. A simple hello world test looks like the code below, where describe() describes a suite of tests and it() is an individual test specification. The name "it()" follows the idea of behavior-driven development and serves as the first word in the test name, which should be a complete sentence. Usage follows syntax similar to that of RSpec.<ref name="Usage">http://en.wikipedia.org/wiki/Jasmine_(JavaScript_framework)</ref>

describe('Hello world', function() { 
   it('says hello', function() {
   expect(helloWorld()).toEqual("Hello world!");
 });
});

Features

Suites

A test suite begins with a call to the global Jasmine function describe with two parameters: a string and a function. The string is a name or title for a spec suite – usually what is under test. The function is a block of code that implements the suite.<ref name="Features">http://jasmine.github.io/1.3/introduction.html</ref>

describe("A suite", function() {
 it("contains spec with an expectation", function() {
   expect(true).toBe(true);
 });
});

Specs

Specs are defined by calling the global Jasmine function it, which, like describe takes a string and a function. The string is a title for this spec and the function is the spec, or test. A spec contains one or more expectations that test the state of the code under test.<ref name="Features"/>

An expectation in Jasmine is an assertion that can be either true or false. A spec with all true expectations is a passing spec. A spec with one or more expectations that evaluate to false is a failing spec.

describe("A suite is just a function", function() {
 var a;
 it("and so is a spec", function() {
   a = true;
  expect(a).toBe(true);
 });
});

Disabling Specs and Suits

Suites and specs can be disabled with the xdescribe and xit functions, respectively. These suites and specs are skipped when run and thus their results will not appear in the results.<ref name="Features"/>

xdescribe("A spec", function() {
 var foo;
 beforeEach(function() {
   foo = 0;
   foo += 1;
 });
 xit("is just a function, so it can contain any code", function() {
   expect(foo).toEqual(1);
 });
});

Expectations

Expectations are built with the function expect which takes a value, called the actual. It is chained with a Matcher function, which takes the expected value.<ref name="Features"/>

Matchers

Each matcher implements a boolean comparison between the actual value and the expected value. It is responsible for reporting to Jasmine if the expectation is true or false. Jasmine will then pass or fail the spec.Any matcher can evaluate to a negative assertion by chaining the call to expect with a not before calling the matcher.<ref name="Features"/>

describe("The 'toBe' matcher compares with ===", function() {
 it("and has a positive case ", function() {
   expect(true).toBe(true);
 });
it("and can have a negative case", function() {
   expect(false).not.toBe(true);
 });
});

Included Matchers

Jasmine has a rich set of matchers included. Some of them are listed below.<ref name="Included Matchers">http://www.htmlgoodies.com/beyond/javascript/testing-javascript-using-the-jasmine-framework.html</ref>

• toBe: represents the exact equality (===) operator.
• toEqual: represents the regular equality (==) operator.
• toMatch: calls the RegExp match() method behind the scenes to compare string data.
• toBeDefined: opposite of the JS "undefined" constant.
• toBeUndefined: tests the actual against "undefined".
• toBeNull: tests the actual against a null value - useful for certain functions that may return null, like those of regular expressions (same as toBe(null))
• toBeTruthy: simulates JavaScript boolean casting.
• toBeFalsy: like toBeTruthy, but tests against anything that evaluates to false, such as empty strings, zero, undefined, etc…
• toContain: performs a search on an array for the actual value.
• toBeLessThan/toBeGreaterThan: for numerical comparisons.
• toBeCloseTo: for floating point comparisons.
• toThrow: for catching expected exceptions.

There is also the ability to write custom matcherswhen a project

References

<references/>