github-migration/jasmine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Doc fixes. Really, markdown? Really?

Browse Source
This commit is contained in:
ragaskar 2009-03-01 05:47:02 -08:00
parent 2c8c3464b2
commit 9404716322
1 changed files with 69 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
README.markdown
View File

@ -55,7 +55,7 @@ Well, say you need to make a call that is asynchronous - an AJAX API, or some ot
Jasmine allows you to do this with `runs()` and `waits()` blocks.
`runs()` blocks by themselves simply run as if they were called directly. The following snippets of code should provide similar results:
`runs()` blocks by themselves simply run as if they were called directly. The following snippets of code should provide similar results:
it('should be a test', function () {
@ -65,7 +65,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
expect(foo).toEqual(1);
});
and
and
it('should be a test', function () {
runs( function () {
@ -76,7 +76,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
});
});
multiple `runs()` blocks in a spec will run serially. For example,
multiple `runs()` blocks in a spec will run serially. For example,
it('should be a test', function () {
runs( function () {
@ -93,7 +93,7 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
});
});
`runs()` blocks share functional scope -- `this` properties will be common to all blocks, but simple vars will not!
`runs()` blocks share functional scope -- `this` properties will be common to all blocks, but simple `vars` will not!
it('should be a test', function () {
runs( function () {
@ -115,8 +115,8 @@ Jasmine allows you to do this with `runs()` and `waits()` blocks.
});
});
`runs()` blocks exist so you can test asynchronous processes. The function `waits()` works with `runs()` to provide a naive
timeout before the next block is run. You supply a time to wait before the next `runs()` function is executed. For example:
`runs()` blocks exist so you can test asynchronous processes. The function `waits()` works with `runs()` to provide a naive
timeout before the next block is run. You supply a time to wait before the next `runs()` function is executed. For example:
it('should be a test', function () {
runs(function () {
@ -205,17 +205,29 @@ There is a `Jasmine.Reporters` namespace for you to see how to handle reporting.
Jasmine has several matchers:
`toEqual` compares objects or primitives and returns true if they are equal
`toNotEqual` compares objects or primitives and returns true if they are not equal
`toMatch` takes a regex or a string and returns true if it matches
`toNotMatch` takes a regex or a string and returns true if it does not match
`toBeDefined` returns true if the object or primitive is not `undefined`
`toBeNull` returns true if the object or primitive is not `null`
`toBeTruthy` returns true if the object or primitive evaluates to true
`toBeFalsy` returns true if the object or primitive evaluates to false
`wasCalled` returns true if the object is a spy and was called
`wasNotCalled` returns true if the object is a spy and was not called
`wasNotCalledWith` returns true if the object is a spy and was called with the passed arguments
`toContain` returns true if an array or string contains the passed variable.
`toNotContain` returns true if an array or string does not contain the passed variable.
### Writing new Matchers
@ -237,79 +249,85 @@ suites may be disabled by calling `xdescribe()` instead of `describe()`
beforeEach takes a function that is run before each spec. For example:
describe('some suite', function () {
describe('some suite', function () {
var suiteWideFoo;
beforeEach(function () {
suiteWideFoo = 1;
}
var suiteWideFoo;
beforeEach(function () {
suiteWideFoo = 1;
}
it('should equal bar', function () {
expect(suiteWideFoo).toEqual(1);
};
});
it('should equal bar', function () {
expect(suiteWideFoo).toEqual(1);
};
});
### afterEach
afterEach takes a function that is run after each spec. For example:
describe('some suite', function () {
describe('some suite', function () {
var suiteWideFoo;
afterEach(function () {
suiteWideFoo = 0;
}
var suiteWideFoo;
afterEach(function () {
suiteWideFoo = 0;
}
it('should equal 1', function () {
expect(suiteWideFoo).toEqual(1);
};
it('should equal 1', function () {
expect(suiteWideFoo).toEqual(1);
};
it('should equal 0 after', function () {
expect(suiteWideFoo).toEqual(0);
};
});
it('should equal 0 after', function () {
expect(suiteWideFoo).toEqual(0);
};
});
### Spies
Jasmine integrates 'spies' that permit many spying, mocking, and faking behaviors.
Here is an few examples:
Here are a few examples:
var Klass = function () {
}
var Klass = function () {
}
var Klass.prototype.method = function (arg) {
var Klass.prototype.method = function (arg) {
return arg;
}
}
var Klass.prototype.methodWithCallback = function (callback) {
var Klass.prototype.methodWithCallback = function (callback) {
return callback('foo');
}
}
...
it('should spy on Klass#method') {
it('should spy on Klass#method') {
spyOn(Klass, 'method');
Klass.method('foo argument');
expect(Klass.method).wasCalledWith('foo argument');
}
});
it('should spy on Klass#methodWithCallback') {
it('should spy on Klass#methodWithCallback') {
var callback = Jasmine.createSpy();
Klass.method(callback);
expect(callback).wasCalledWith('foo');
}
});
Many other options are available for spies:
`andCallThrough()`: spies on AND calls the original function spied on
`andReturn()`: returns passed arguments when spy is called
`andThrow()`: throws passed exception when spy is called
`andCallFake()`: calls passed function when spy is called
`callCount`: returns number of times spy was called
`mostRecentCall.args`: returns argument array from last call to spy.
`argsForCall[i]` returns arguments array for call `i` to spy.
Spies are automatically removed after each spec. They may be set in the beforeEach function.