2009-05-29 03:02:15 +00:00
describe ( "jasmine spec running" , function ( ) {
var env ;
var fakeTimer ;
beforeEach ( function ( ) {
env = new jasmine . Env ( ) ;
2009-10-06 05:36:10 +00:00
env . updateInterval = 0 ;
2009-05-29 03:02:15 +00:00
fakeTimer = new jasmine . FakeTimer ( ) ;
env . setTimeout = fakeTimer . setTimeout ;
env . clearTimeout = fakeTimer . clearTimeout ;
env . setInterval = fakeTimer . setInterval ;
env . clearInterval = fakeTimer . clearInterval ;
} ) ;
it ( 'should assign spec ids sequentially' , function ( ) {
var it0 , it1 , it2 , it3 , it4 ;
env . describe ( 'test suite' , function ( ) {
it0 = env . it ( 'spec 0' , function ( ) {
} ) ;
it1 = env . it ( 'spec 1' , function ( ) {
} ) ;
it2 = env . xit ( 'spec 2' , function ( ) {
} ) ;
it3 = env . it ( 'spec 3' , function ( ) {
} ) ;
} ) ;
env . describe ( 'test suite 2' , function ( ) {
it4 = env . it ( 'spec 4' , function ( ) {
} ) ;
} ) ;
expect ( it0 . id ) . toEqual ( 0 ) ;
expect ( it1 . id ) . toEqual ( 1 ) ;
expect ( it2 . id ) . toEqual ( 2 ) ;
expect ( it3 . id ) . toEqual ( 3 ) ;
expect ( it4 . id ) . toEqual ( 4 ) ;
} ) ;
it ( "should build up some objects with results we can inspect" , function ( ) {
2009-08-01 22:28:39 +00:00
2009-05-29 03:02:15 +00:00
var specWithNoBody , specWithExpectation , specWithFailingExpectations , specWithMultipleExpectations ;
var suite = env . describe ( 'default current suite' , function ( ) {
specWithNoBody = env . it ( 'new spec' ) ;
specWithExpectation = env . it ( 'spec with an expectation' ) . runs ( function ( ) {
var foo = 'bar' ;
this . expect ( foo ) . toEqual ( 'bar' ) ;
} ) ;
specWithFailingExpectations = env . it ( 'spec with failing expectation' ) . runs ( function ( ) {
var foo = 'bar' ;
this . expect ( foo ) . toEqual ( 'baz' ) ;
} ) ;
specWithMultipleExpectations = env . it ( 'spec with multiple assertions' ) . runs ( function ( ) {
var foo = 'bar' ;
var baz = 'quux' ;
this . expect ( foo ) . toEqual ( 'bar' ) ;
this . expect ( baz ) . toEqual ( 'quux' ) ;
} ) ;
} ) ;
suite . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-05-29 03:02:15 +00:00
expect ( specWithNoBody . description ) . toEqual ( 'new spec' ) ;
2009-09-28 18:13:44 +00:00
expect ( specWithExpectation . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ; // "Results aren't there after a spec was executed"
expect ( specWithExpectation . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ; // "Results has a result, but it's true"
expect ( specWithExpectation . results ( ) . description ) . toEqual ( 'spec with an expectation' ) ; // "Spec's results did not get the spec's description"
2009-05-29 03:02:15 +00:00
2009-09-28 18:13:44 +00:00
expect ( specWithFailingExpectations . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( false ) ; // "Expectation that failed, passed"
2009-05-29 03:02:15 +00:00
2009-09-28 18:13:44 +00:00
expect ( specWithMultipleExpectations . results ( ) . getItems ( ) . length ) . toEqual ( 2 ) ; // "Spec doesn't support multiple expectations"
2009-05-29 03:02:15 +00:00
} ) ;
it ( "should work without a runs block" , function ( ) {
var another _spec ;
2009-07-30 05:27:11 +00:00
env . describe ( 'default current suite' , function ( ) {
2009-05-29 03:02:15 +00:00
another _spec = env . it ( 'spec with an expectation' , function ( ) {
var foo = 'bar' ;
this . expect ( foo ) . toEqual ( 'bar' ) ;
this . expect ( foo ) . toEqual ( 'baz' ) ;
} ) ;
} ) ;
another _spec . execute ( ) ;
another _spec . done = true ;
2009-09-28 18:13:44 +00:00
expect ( another _spec . results ( ) . getItems ( ) . length ) . toEqual ( 2 ) ;
expect ( another _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ; // "In a spec without a run block, expected first expectation result to be true but was false"
expect ( another _spec . results ( ) . getItems ( ) [ 1 ] . passed ( ) ) . toEqual ( false ) ; // "In a spec without a run block, expected second expectation result to be false but was true";
expect ( another _spec . results ( ) . description ) . toEqual ( 'spec with an expectation' ) ; // "In a spec without a run block, results did not include the spec's description";
2009-05-29 03:02:15 +00:00
} ) ;
2009-07-30 05:27:11 +00:00
it ( 'should queue waits and runs that it encounters while executing specs' , function ( ) {
var specWithRunsAndWaits ;
2009-08-01 21:56:29 +00:00
var foo = 0 ;
2009-07-30 05:27:11 +00:00
env . describe ( 'test async spec' , function ( ) {
specWithRunsAndWaits = env . it ( 'spec w/ queued statments' , function ( ) {
this . runs ( function ( ) {
2009-08-01 21:56:29 +00:00
foo ++ ;
2009-07-30 05:27:11 +00:00
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
2009-08-01 21:56:29 +00:00
foo ++ ;
2009-07-30 05:27:11 +00:00
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
2009-08-01 21:56:29 +00:00
foo ++ ;
2009-07-30 05:27:11 +00:00
} ) ;
} ) ;
} ) ;
2009-08-01 21:56:29 +00:00
expect ( foo ) . toEqual ( 0 ) ;
2009-07-30 05:27:11 +00:00
specWithRunsAndWaits . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-08-01 21:56:29 +00:00
expect ( foo ) . toEqual ( 1 ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 2 ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 3 ) ;
2009-07-30 05:27:11 +00:00
} ) ;
2009-05-29 03:02:15 +00:00
it ( "should run asynchronous tests" , function ( ) {
var foo = 0 ;
var a _spec ;
env . describe ( 'test async spec' , function ( ) {
a _spec = env . it ( 'spec w/ queued statments' , function ( ) {
this . runs ( function ( ) {
foo ++ ;
} ) ;
this . runs ( function ( ) {
this . expect ( foo ) . toEqual ( 1 ) ;
} ) ;
} ) ;
} ) ;
a _spec . execute ( ) ;
2009-09-28 18:13:44 +00:00
expect ( a _spec . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ; // 'No call to waits(): Spec queue did not run all functions';
expect ( a _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ; // 'No call to waits(): Queued expectation failed';
2009-05-29 03:02:15 +00:00
foo = 0 ;
env . describe ( 'test async spec' , function ( ) {
a _spec = env . it ( 'spec w/ queued statments' , function ( ) {
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
foo ++ ;
} , 500 ) ;
} ) ;
this . waits ( 1000 ) ;
this . runs ( function ( ) {
this . expect ( foo ) . toEqual ( 1 ) ;
} ) ;
} ) ;
} ) ;
a _spec . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-09-28 18:13:44 +00:00
expect ( a _spec . results ( ) . getItems ( ) . length ) . toEqual ( 0 ) ;
2009-05-29 03:02:15 +00:00
fakeTimer . tick ( 500 ) ;
2009-09-28 18:13:44 +00:00
expect ( a _spec . results ( ) . getItems ( ) . length ) . toEqual ( 0 ) ;
2009-05-29 03:02:15 +00:00
fakeTimer . tick ( 500 ) ;
2009-09-28 18:13:44 +00:00
expect ( a _spec . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ; // 'Calling waits(): Spec queue did not run all functions';
2009-05-29 03:02:15 +00:00
2009-09-28 18:13:44 +00:00
expect ( a _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ; // 'Calling waits(): Queued expectation failed';
2009-05-29 03:02:15 +00:00
var bar = 0 ;
var another _spec ;
env . describe ( 'test async spec' , function ( ) {
another _spec = env . it ( 'spec w/ queued statments' , function ( ) {
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
bar ++ ;
} , 250 ) ;
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
bar ++ ;
} , 250 ) ;
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
this . expect ( bar ) . toEqual ( 2 ) ;
} ) ;
} ) ;
} ) ;
another _spec . execute ( ) ;
fakeTimer . tick ( 1000 ) ;
2009-09-28 18:13:44 +00:00
expect ( another _spec . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ;
expect ( another _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ;
2009-05-29 03:02:15 +00:00
var baz = 0 ;
var yet _another _spec ;
env . describe ( 'test async spec' , function ( ) {
yet _another _spec = env . it ( 'spec w/ async fail' , function ( ) {
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
baz ++ ;
} , 250 ) ;
} ) ;
this . waits ( 100 ) ;
this . runs ( function ( ) {
this . expect ( baz ) . toEqual ( 1 ) ;
} ) ;
} ) ;
} ) ;
yet _another _spec . execute ( ) ;
2009-08-13 14:52:44 +00:00
//tick twice so that second runs gets eval'd first: mockClock bug?
fakeTimer . tick ( 100 ) ;
fakeTimer . tick ( 150 ) ;
2009-05-29 03:02:15 +00:00
2009-09-28 18:13:44 +00:00
expect ( yet _another _spec . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ;
expect ( yet _another _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( false ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "testAsyncSpecsWithMockSuite" , function ( ) {
var bar = 0 ;
var another _spec ;
env . describe ( 'test async spec' , function ( ) {
another _spec = env . it ( 'spec w/ queued statments' , function ( ) {
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
bar ++ ;
} , 250 ) ;
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
fakeTimer . setTimeout ( function ( ) {
bar ++ ;
} , 250 ) ;
} ) ;
this . waits ( 1500 ) ;
this . runs ( function ( ) {
this . expect ( bar ) . toEqual ( 2 ) ;
} ) ;
} ) ;
} ) ;
another _spec . execute ( ) ;
fakeTimer . tick ( 2000 ) ;
2009-09-28 18:13:44 +00:00
expect ( another _spec . results ( ) . getItems ( ) . length ) . toEqual ( 1 ) ;
expect ( another _spec . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "testWaitsFor" , function ( ) {
var doneWaiting = false ;
var runsBlockExecuted = false ;
var spec ;
env . describe ( 'foo' , function ( ) {
spec = env . it ( 'has a waits for' , function ( ) {
this . runs ( function ( ) {
} ) ;
this . waitsFor ( 500 , function ( ) {
return doneWaiting ;
} ) ;
this . runs ( function ( ) {
runsBlockExecuted = true ;
} ) ;
} ) ;
} ) ;
spec . execute ( ) ;
expect ( runsBlockExecuted ) . toEqual ( false ) ; //, 'should not have executed runs block yet');
fakeTimer . tick ( 100 ) ;
doneWaiting = true ;
fakeTimer . tick ( 100 ) ;
expect ( runsBlockExecuted ) . toEqual ( true ) ; //, 'should have executed runs block');
} ) ;
it ( "testWaitsForFailsWithMessage" , function ( ) {
var spec ;
env . describe ( 'foo' , function ( ) {
spec = env . it ( 'has a waits for' , function ( ) {
this . runs ( function ( ) {
} ) ;
this . waitsFor ( 500 , function ( ) {
return false ; // force a timeout
} , 'my awesome condition' ) ;
this . runs ( function ( ) {
} ) ;
} ) ;
} ) ;
spec . execute ( ) ;
fakeTimer . tick ( 1000 ) ;
2009-09-28 18:13:44 +00:00
var actual = spec . results ( ) . getItems ( ) [ 0 ] . message ;
2009-05-29 03:02:15 +00:00
var expected = 'timeout: timed out after 500 msec waiting for my awesome condition' ;
expect ( actual ) . toEqual ( expected ) ;
} ) ;
2009-07-30 05:27:11 +00:00
it ( "waitsFor fails and skips the rest of the spec if timeout is reached and the latch function is still false" , function ( ) {
2009-05-29 03:02:15 +00:00
var runsBlockExecuted = false ;
var spec ;
env . describe ( 'foo' , function ( ) {
spec = env . it ( 'has a waits for' , function ( ) {
this . runs ( function ( ) {
} ) ;
this . waitsFor ( 500 , function ( ) {
2009-07-30 05:27:11 +00:00
return false ;
2009-05-29 03:02:15 +00:00
} ) ;
this . runs ( function ( ) {
runsBlockExecuted = true ;
} ) ;
} ) ;
} ) ;
spec . execute ( ) ;
2009-07-30 05:27:11 +00:00
expect ( runsBlockExecuted ) . toEqual ( false ) ;
2009-05-29 03:02:15 +00:00
fakeTimer . tick ( 100 ) ;
2009-07-30 05:27:11 +00:00
expect ( runsBlockExecuted ) . toEqual ( false ) ;
2009-05-29 03:02:15 +00:00
fakeTimer . tick ( 400 ) ;
2009-07-30 05:27:11 +00:00
expect ( runsBlockExecuted ) . toEqual ( false ) ;
2009-09-28 18:13:44 +00:00
var actual = spec . results ( ) . getItems ( ) [ 0 ] . message ;
2009-05-29 03:02:15 +00:00
var expected = 'timeout: timed out after 500 msec waiting for something to happen' ;
expect ( actual ) . toEqual ( expected ,
2009-08-21 02:32:15 +00:00
'expected "' + expected + '" but found "' + actual + '"' ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "testSpecAfter" , function ( ) {
var log = "" ;
var spec ;
var suite = env . describe ( "has after" , function ( ) {
spec = env . it ( 'spec with after' , function ( ) {
this . runs ( function ( ) {
log += "spec" ;
} ) ;
} ) ;
} ) ;
spec . after ( function ( ) {
log += "after1" ;
} ) ;
spec . after ( function ( ) {
log += "after2" ;
} ) ;
suite . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-08-01 22:28:39 +00:00
expect ( log ) . toEqual ( "specafter2after1" ) ;
2009-05-29 03:02:15 +00:00
} ) ;
describe ( 'test suite declaration' , function ( ) {
var suite ;
2009-07-30 05:27:11 +00:00
var dummyFunction = function ( ) {
} ;
2009-05-29 03:02:15 +00:00
it ( 'should give the suite a description' , function ( ) {
suite = env . describe ( 'one suite description' , dummyFunction ) ;
2009-07-30 05:27:11 +00:00
expect ( suite . description ) . toEqual ( 'one suite description' ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( 'should enqueue functions for multipart tests and support waits, and run any ready runs() blocks' , function ( ) {
var foo = 0 ;
var bar = 0 ;
suite = env . describe ( 'one suite description' , function ( ) {
env . it ( 'should be a test with queuedFunctions' , function ( ) {
this . runs ( function ( ) {
foo ++ ;
} ) ;
this . waits ( 100 ) ;
this . runs ( function ( ) {
bar ++ ;
} ) ;
} ) ;
} ) ;
suite . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-05-29 03:02:15 +00:00
expect ( foo ) . toEqual ( 1 ) ;
expect ( bar ) . toEqual ( 0 ) ;
fakeTimer . tick ( 100 ) ;
expect ( bar ) . toEqual ( 1 ) ;
} ) ;
} ) ;
it ( "testBeforeAndAfterCallbacks" , function ( ) {
var suiteWithBefore = env . describe ( 'one suite with a before' , function ( ) {
this . beforeEach ( function ( ) {
this . foo = 1 ;
} ) ;
env . it ( 'should be a spec' , function ( ) {
this . runs ( function ( ) {
this . foo ++ ;
this . expect ( this . foo ) . toEqual ( 2 ) ;
} ) ;
} ) ;
env . it ( 'should be another spec' , function ( ) {
this . runs ( function ( ) {
this . foo ++ ;
this . expect ( this . foo ) . toEqual ( 2 ) ;
} ) ;
} ) ;
} ) ;
suiteWithBefore . execute ( ) ;
2009-08-19 14:42:47 +00:00
2009-05-29 03:02:15 +00:00
var suite = suiteWithBefore ;
2009-09-28 18:13:44 +00:00
expect ( suite . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ; // "testBeforeAndAfterCallbacks: the first spec's foo should have been 2");
expect ( suite . results ( ) . getItems ( ) [ 1 ] . passed ( ) ) . toEqual ( true ) ; // "testBeforeAndAfterCallbacks: the second spec's this.foo should have been 2");
2009-08-01 22:28:39 +00:00
2009-05-29 03:02:15 +00:00
2009-08-01 22:28:39 +00:00
var foo = 1 ;
2009-05-29 03:02:15 +00:00
var suiteWithAfter = env . describe ( 'one suite with an after_each' , function ( ) {
env . it ( 'should be a spec with an after_each' , function ( ) {
2009-08-01 22:28:39 +00:00
this . expect ( foo ) . toEqual ( 1 ) ;
foo ++ ;
this . expect ( foo ) . toEqual ( 2 ) ;
2009-05-29 03:02:15 +00:00
} ) ;
env . it ( 'should be another spec with an after_each' , function ( ) {
2009-08-01 22:28:39 +00:00
this . expect ( foo ) . toEqual ( 0 ) ;
foo ++ ;
this . expect ( foo ) . toEqual ( 1 ) ;
2009-05-29 03:02:15 +00:00
} ) ;
this . afterEach ( function ( ) {
2009-08-01 22:28:39 +00:00
foo = 0 ;
2009-05-29 03:02:15 +00:00
} ) ;
} ) ;
suiteWithAfter . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-07-30 05:27:11 +00:00
suite = suiteWithAfter ;
2009-08-01 22:28:39 +00:00
expect ( suite . afterEach . length ) . toEqual ( 1 ) ;
2009-09-28 18:13:44 +00:00
expect ( suite . results ( ) . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ;
expect ( suite . results ( ) . getItems ( ) [ 1 ] . passed ( ) ) . toEqual ( true ) ;
2009-08-01 22:28:39 +00:00
expect ( foo ) . toEqual ( 0 ) ;
2009-05-29 03:02:15 +00:00
} ) ;
2009-07-30 05:27:11 +00:00
it ( '#waits should allow consecutive waits calls' , function ( ) {
var foo = 0 ;
var waitsSuite = env . describe ( 'suite that waits' , function ( ) {
env . it ( 'should wait' , function ( ) {
this . waits ( 500 ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
foo ++ ;
} ) ;
} ) ;
} ) ;
waitsSuite . execute ( ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 1 ) ;
} ) ;
2009-08-01 22:28:39 +00:00
it ( 'nested suites' , function ( ) {
2009-09-02 04:21:54 +00:00
2009-08-01 22:28:39 +00:00
var foo = 0 ;
var bar = 0 ;
var baz = 0 ;
var quux = 0 ;
var nested = env . describe ( 'suite' , function ( ) {
env . describe ( 'nested' , function ( ) {
env . it ( 'should run nested suites' , function ( ) {
foo ++ ;
} ) ;
env . it ( 'should run nested suites' , function ( ) {
bar ++ ;
} ) ;
} ) ;
env . describe ( 'nested 2' , function ( ) {
env . it ( 'should run suites following nested suites' , function ( ) {
baz ++ ;
} ) ;
} ) ;
env . it ( 'should run tests following nested suites' , function ( ) {
2009-08-21 02:32:15 +00:00
quux ++ ;
} ) ;
2009-08-01 22:28:39 +00:00
} ) ;
expect ( foo ) . toEqual ( 0 ) ;
expect ( bar ) . toEqual ( 0 ) ;
expect ( baz ) . toEqual ( 0 ) ;
expect ( quux ) . toEqual ( 0 ) ;
nested . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-08-01 22:28:39 +00:00
expect ( foo ) . toEqual ( 1 ) ;
expect ( bar ) . toEqual ( 1 ) ;
expect ( baz ) . toEqual ( 1 ) ;
expect ( quux ) . toEqual ( 1 ) ;
} ) ;
2009-07-30 05:27:11 +00:00
describe ( '#waitsFor should allow consecutive calls' , function ( ) {
2009-08-01 22:28:39 +00:00
2009-07-30 05:27:11 +00:00
var foo ;
beforeEach ( function ( ) {
2009-08-01 22:28:39 +00:00
2009-07-30 05:27:11 +00:00
foo = 0 ;
} ) ;
it ( 'exits immediately (does not stack) if the latchFunction times out' , function ( ) {
var reachedFirstWaitsFor = false ;
var reachedSecondWaitsFor = false ;
var waitsSuite = env . describe ( 'suite that waits' , function ( ) {
env . it ( 'should stack timeouts' , function ( ) {
2009-08-01 22:28:39 +00:00
this . waitsFor ( 500 , function ( ) {
reachedFirstWaitsFor = true ;
return false ;
} ) ;
this . waitsFor ( 500 , function ( ) {
reachedSecondWaitsFor = true ;
} ) ;
2009-07-30 05:27:11 +00:00
this . runs ( function ( ) {
foo ++ ;
} ) ;
} ) ;
} ) ;
expect ( reachedFirstWaitsFor ) . toEqual ( false ) ;
waitsSuite . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-07-30 05:27:11 +00:00
expect ( reachedFirstWaitsFor ) . toEqual ( true ) ;
expect ( foo ) . toEqual ( 0 ) ;
expect ( reachedSecondWaitsFor ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( reachedSecondWaitsFor ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 500 ) ;
expect ( reachedSecondWaitsFor ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
} ) ;
it ( 'stacks latchFunctions' , function ( ) {
var firstWaitsResult = false ;
var secondWaitsResult = false ;
var waitsSuite = env . describe ( 'suite that waits' , function ( ) {
env . it ( 'spec with waitsFors' , function ( ) {
2009-08-01 22:28:39 +00:00
this . waitsFor ( 600 , function ( ) {
fakeTimer . setTimeout ( function ( ) {
firstWaitsResult = true ;
} , 300 ) ;
return firstWaitsResult ;
} ) ;
this . waitsFor ( 600 , function ( ) {
fakeTimer . setTimeout ( function ( ) {
secondWaitsResult = true ;
} , 300 ) ;
return secondWaitsResult ;
} ) ;
2009-07-30 05:27:11 +00:00
this . runs ( function ( ) {
foo ++ ;
} ) ;
} ) ;
} ) ;
expect ( firstWaitsResult ) . toEqual ( false ) ;
expect ( secondWaitsResult ) . toEqual ( false ) ;
waitsSuite . execute ( ) ;
expect ( firstWaitsResult ) . toEqual ( false ) ;
expect ( secondWaitsResult ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 300 ) ;
expect ( firstWaitsResult ) . toEqual ( true ) ;
expect ( secondWaitsResult ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 300 ) ;
expect ( firstWaitsResult ) . toEqual ( true ) ;
expect ( secondWaitsResult ) . toEqual ( true ) ;
expect ( foo ) . toEqual ( 1 ) ;
} ) ;
} ) ;
2009-08-04 06:09:50 +00:00
it ( "#beforeEach should be able to eval runs and waits blocks" , function ( ) {
2009-07-30 05:27:11 +00:00
var foo = 0 ;
var bar = 0 ;
var suiteWithBefore = env . describe ( 'one suite with a before' , function ( ) {
this . beforeEach ( function ( ) {
this . runs ( function ( ) {
foo ++ ;
} ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
foo ++ ;
} ) ;
this . waits ( 500 ) ;
} ) ;
env . it ( 'should be a spec' , function ( ) {
bar = 1 ;
foo ++ ;
} ) ;
} ) ;
2009-08-01 17:43:03 +00:00
expect ( foo ) . toEqual ( 0 ) ;
2009-07-30 05:27:11 +00:00
expect ( bar ) . toEqual ( 0 ) ;
suiteWithBefore . execute ( ) ;
2009-08-01 17:43:03 +00:00
2009-07-30 05:27:11 +00:00
expect ( bar ) . toEqual ( 0 ) ;
2009-08-01 17:43:03 +00:00
expect ( foo ) . toEqual ( 1 ) ;
2009-07-30 05:27:11 +00:00
fakeTimer . tick ( 500 ) ;
2009-08-01 17:43:03 +00:00
2009-07-30 05:27:11 +00:00
expect ( bar ) . toEqual ( 0 ) ;
2009-08-01 17:43:03 +00:00
expect ( foo ) . toEqual ( 2 ) ;
2009-07-30 05:27:11 +00:00
fakeTimer . tick ( 500 ) ;
expect ( bar ) . toEqual ( 1 ) ;
2009-08-01 17:43:03 +00:00
expect ( foo ) . toEqual ( 3 ) ;
2009-07-30 05:27:11 +00:00
} ) ;
2009-08-04 14:12:39 +00:00
it ( "#afterEach should be able to eval runs and waits blocks" , function ( ) {
var foo = 0 ;
var firstSpecHasRun = false ;
var secondSpecHasRun = false ;
var suiteWithAfter = env . describe ( 'one suite with a before' , function ( ) {
this . afterEach ( function ( ) {
this . waits ( 500 ) ;
this . runs ( function ( ) {
foo ++ ;
} ) ;
this . waits ( 500 ) ;
} ) ;
env . it ( 'should be the first spec' , function ( ) {
firstSpecHasRun = true ;
} ) ;
env . it ( 'should be a spec' , function ( ) {
secondSpecHasRun = true ;
foo ++ ;
} ) ;
} ) ;
expect ( firstSpecHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
suiteWithAfter . execute ( ) ;
2009-08-13 14:52:44 +00:00
2009-08-04 14:12:39 +00:00
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
expect ( foo ) . toEqual ( 0 ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 1 ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( foo ) . toEqual ( 2 ) ;
expect ( secondSpecHasRun ) . toEqual ( true ) ;
} ) ;
2009-08-05 02:24:00 +00:00
it ( "Spec#after should be able to eval runs and waits blocks" , function ( ) {
var runsBeforeAfter = false ;
var firstSpecHasRun = false ;
var secondSpecHasRun = false ;
var afterHasRun = false ;
var suiteWithAfter = env . describe ( 'one suite with a before' , function ( ) {
env . it ( 'should be the first spec' , function ( ) {
firstSpecHasRun = true ;
this . after ( function ( ) {
this . waits ( 500 ) ;
this . runs ( function ( ) {
2009-08-21 02:32:15 +00:00
afterHasRun = true ;
2009-08-05 02:24:00 +00:00
} ) ;
this . waits ( 500 ) ;
} , true ) ;
this . waits ( 500 ) ;
this . runs ( function ( ) {
runsBeforeAfter = true ;
} ) ;
} ) ;
env . it ( 'should be a spec' , function ( ) {
secondSpecHasRun = true ;
} ) ;
} ) ;
expect ( firstSpecHasRun ) . toEqual ( false ) ;
expect ( runsBeforeAfter ) . toEqual ( false ) ;
expect ( afterHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
suiteWithAfter . execute ( ) ;
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( runsBeforeAfter ) . toEqual ( false ) ;
expect ( afterHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( runsBeforeAfter ) . toEqual ( true ) ;
expect ( afterHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( runsBeforeAfter ) . toEqual ( true ) ;
expect ( afterHasRun ) . toEqual ( true ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( runsBeforeAfter ) . toEqual ( true ) ;
expect ( afterHasRun ) . toEqual ( true ) ;
expect ( secondSpecHasRun ) . toEqual ( true ) ;
} ) ;
it ( "handles waits" , function ( ) {
var firstSpecHasRun = false ;
var secondSpecHasRun = false ;
var suiteWithAfter = env . describe ( 'one suite with a before' , function ( ) {
env . it ( 'should be the first spec' , function ( ) {
this . waits ( 500 ) ;
this . runs ( function ( ) {
firstSpecHasRun = true ;
} ) ;
} ) ;
env . it ( 'should be a spec' , function ( ) {
secondSpecHasRun = true ;
} ) ;
} ) ;
expect ( firstSpecHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
suiteWithAfter . execute ( ) ;
expect ( firstSpecHasRun ) . toEqual ( false ) ;
expect ( secondSpecHasRun ) . toEqual ( false ) ;
fakeTimer . tick ( 500 ) ;
expect ( firstSpecHasRun ) . toEqual ( true ) ;
expect ( secondSpecHasRun ) . toEqual ( true ) ;
2009-08-21 02:32:15 +00:00
} ) ;
2009-08-05 02:24:00 +00:00
2009-05-29 03:02:15 +00:00
it ( "testBeforeExecutesSafely" , function ( ) {
var report = "" ;
var suite = env . describe ( 'before fails on first test, passes on second' , function ( ) {
var counter = 0 ;
this . beforeEach ( function ( ) {
counter ++ ;
if ( counter == 1 ) {
throw "before failure" ;
}
} ) ;
env . it ( "first should not run because before fails" , function ( ) {
this . runs ( function ( ) {
report += "first" ;
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
env . it ( "second should run and pass because before passes" , function ( ) {
this . runs ( function ( ) {
report += "second" ;
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
} ) ;
suite . execute ( ) ;
2009-08-01 22:28:39 +00:00
expect ( report ) . toEqual ( "firstsecond" ) ;
2009-09-28 18:13:44 +00:00
var suiteResults = suite . results ( ) ;
2009-08-19 14:42:47 +00:00
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( false ) ;
expect ( suiteResults . getItems ( ) [ 1 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "testAfterExecutesSafely" , function ( ) {
var report = "" ;
var suite = env . describe ( 'after fails on first test, then passes' , function ( ) {
var counter = 0 ;
this . afterEach ( function ( ) {
counter ++ ;
if ( counter == 1 ) {
throw "after failure" ;
}
} ) ;
env . it ( "first should run, expectation passes, but spec fails because after fails" , function ( ) {
this . runs ( function ( ) {
report += "first" ;
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
env . it ( "second should run and pass because after passes" , function ( ) {
this . runs ( function ( ) {
report += "second" ;
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
env . it ( "third should run and pass because after passes" , function ( ) {
this . runs ( function ( ) {
report += "third" ;
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
} ) ;
suite . execute ( ) ;
expect ( report ) . toEqual ( "firstsecondthird" ) ; // "all tests should run");
//After each errors should not go in spec results because it confuses the count.
2009-09-28 18:13:44 +00:00
var suiteResults = suite . results ( ) ;
2009-08-19 14:42:47 +00:00
expect ( suiteResults . getItems ( ) . length ) . toEqual ( 3 , 'testAfterExecutesSafely should have results for three specs' ) ;
2009-08-01 22:28:39 +00:00
2009-08-19 14:42:47 +00:00
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 1st spec should pass" ) ;
expect ( suiteResults . getItems ( ) [ 1 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 2nd spec should pass" ) ;
expect ( suiteResults . getItems ( ) [ 2 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 3rd spec should pass" ) ;
2009-08-01 22:28:39 +00:00
2009-08-19 14:42:47 +00:00
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 1st result for 1st suite spec should pass" ) ;
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 1 ] . passed ( ) ) . toEqual ( false , "testAfterExecutesSafely 2nd result for 1st suite spec should fail because afterEach failed" ) ;
expect ( suiteResults . getItems ( ) [ 1 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 2nd suite spec should pass" ) ;
expect ( suiteResults . getItems ( ) [ 2 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( true , "testAfterExecutesSafely 3rd suite spec should pass" ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "testNestedDescribes" , function ( ) {
var actions = [ ] ;
2009-09-28 23:23:21 +00:00
env . beforeEach ( function ( ) {
actions . push ( 'runner beforeEach' ) ;
} ) ;
env . afterEach ( function ( ) {
actions . push ( 'runner afterEach' ) ;
} ) ;
2009-05-29 03:02:15 +00:00
env . describe ( 'Something' , function ( ) {
env . beforeEach ( function ( ) {
actions . push ( 'outer beforeEach' ) ;
} ) ;
env . afterEach ( function ( ) {
actions . push ( 'outer afterEach' ) ;
} ) ;
env . it ( 'does it 1' , function ( ) {
actions . push ( 'outer it 1' ) ;
} ) ;
env . describe ( 'Inner 1' , function ( ) {
env . beforeEach ( function ( ) {
actions . push ( 'inner 1 beforeEach' ) ;
} ) ;
env . afterEach ( function ( ) {
actions . push ( 'inner 1 afterEach' ) ;
} ) ;
env . it ( 'does it 2' , function ( ) {
actions . push ( 'inner 1 it' ) ;
} ) ;
} ) ;
env . it ( 'does it 3' , function ( ) {
actions . push ( 'outer it 2' ) ;
} ) ;
env . describe ( 'Inner 2' , function ( ) {
env . beforeEach ( function ( ) {
actions . push ( 'inner 2 beforeEach' ) ;
} ) ;
env . afterEach ( function ( ) {
actions . push ( 'inner 2 afterEach' ) ;
} ) ;
env . it ( 'does it 2' , function ( ) {
actions . push ( 'inner 2 it' ) ;
} ) ;
} ) ;
} ) ;
env . execute ( ) ;
2009-08-21 02:32:15 +00:00
2009-08-04 06:09:50 +00:00
2009-05-29 03:02:15 +00:00
var expected = [
2009-09-28 23:23:21 +00:00
"runner beforeEach" ,
2009-05-29 03:02:15 +00:00
"outer beforeEach" ,
"outer it 1" ,
"outer afterEach" ,
2009-09-28 23:23:21 +00:00
"runner afterEach" ,
2009-05-29 03:02:15 +00:00
2009-09-28 23:23:21 +00:00
"runner beforeEach" ,
2009-05-29 03:02:15 +00:00
"outer beforeEach" ,
"inner 1 beforeEach" ,
"inner 1 it" ,
"inner 1 afterEach" ,
"outer afterEach" ,
2009-09-28 23:23:21 +00:00
"runner afterEach" ,
2009-05-29 03:02:15 +00:00
2009-09-28 23:23:21 +00:00
"runner beforeEach" ,
2009-05-29 03:02:15 +00:00
"outer beforeEach" ,
"outer it 2" ,
"outer afterEach" ,
2009-09-28 23:23:21 +00:00
"runner afterEach" ,
2009-05-29 03:02:15 +00:00
2009-09-28 23:23:21 +00:00
"runner beforeEach" ,
2009-05-29 03:02:15 +00:00
"outer beforeEach" ,
"inner 2 beforeEach" ,
"inner 2 it" ,
"inner 2 afterEach" ,
2009-09-28 23:23:21 +00:00
"outer afterEach" ,
"runner afterEach"
2009-05-29 03:02:15 +00:00
] ;
2009-09-28 23:23:21 +00:00
expect ( actions ) . toEqual ( expected ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "builds up nested names" , function ( ) {
var nestedSpec ;
env . describe ( 'Test Subject' , function ( ) {
env . describe ( 'when under circumstance A' , function ( ) {
env . describe ( 'and circumstance B' , function ( ) {
2009-07-30 05:27:11 +00:00
nestedSpec = env . it ( 'behaves thusly' , function ( ) {
} ) ;
2009-05-29 03:02:15 +00:00
} ) ;
} ) ;
} ) ;
expect ( nestedSpec . getFullName ( ) ) . toEqual ( 'Test Subject when under circumstance A and circumstance B behaves thusly.' ) ; //, "Spec.fullName was incorrect: " + nestedSpec.getFullName());
} ) ;
2009-08-21 02:32:15 +00:00
it ( "should skip empty suites" , function ( ) {
env . describe ( 'NonEmptySuite1' , function ( ) {
env . it ( 'should pass' , function ( ) {
this . expect ( true ) . toEqual ( true ) ;
} ) ;
env . describe ( 'NestedEmptySuite' , function ( ) {
} ) ;
env . it ( 'should pass' , function ( ) {
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
2009-09-28 23:23:21 +00:00
env . describe ( 'EmptySuite' , function ( ) {
} ) ;
2009-08-21 02:32:15 +00:00
env . describe ( 'NonEmptySuite2' , function ( ) {
env . it ( 'should pass' , function ( ) {
this . expect ( true ) . toEqual ( true ) ;
} ) ;
} ) ;
env . execute ( ) ;
2009-09-28 23:23:21 +00:00
var runnerResults = env . currentRunner _ . results ( ) ;
2009-08-21 02:32:15 +00:00
expect ( runnerResults . totalCount ) . toEqual ( 3 ) ;
expect ( runnerResults . passedCount ) . toEqual ( 3 ) ;
expect ( runnerResults . failedCount ) . toEqual ( 0 ) ;
} ) ;
2009-05-29 03:02:15 +00:00
it ( "should bind 'this' to the running spec within the spec body" , function ( ) {
2009-08-01 22:28:39 +00:00
var spec ;
2009-05-29 03:02:15 +00:00
var suite = env . describe ( 'one suite description' , function ( ) {
env . it ( 'should be a test with queuedFunctions' , function ( ) {
2009-08-01 22:28:39 +00:00
spec = this . runs ( function ( ) {
2009-05-29 03:02:15 +00:00
this . foo = 0 ;
this . foo ++ ;
} ) ;
this . runs ( function ( ) {
var that = this ;
fakeTimer . setTimeout ( function ( ) {
that . foo ++ ;
} , 250 ) ;
} ) ;
this . runs ( function ( ) {
this . expect ( this . foo ) . toEqual ( 2 ) ;
} ) ;
this . waits ( 300 ) ;
this . runs ( function ( ) {
this . expect ( this . foo ) . toEqual ( 2 ) ;
} ) ;
} ) ;
} ) ;
suite . execute ( ) ;
fakeTimer . tick ( 600 ) ;
2009-08-01 22:28:39 +00:00
expect ( spec . foo ) . toEqual ( 2 ) ;
2009-09-28 18:13:44 +00:00
var suiteResults = suite . results ( ) ;
2009-08-19 14:42:47 +00:00
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) . length ) . toEqual ( 2 ) ;
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 0 ] . passed ( ) ) . toEqual ( false ) ;
expect ( suiteResults . getItems ( ) [ 0 ] . getItems ( ) [ 1 ] . passed ( ) ) . toEqual ( true ) ;
2009-05-29 03:02:15 +00:00
} ) ;
it ( "shouldn't run disabled tests" , function ( ) {
var xitSpecWasRun = false ;
var suite = env . describe ( 'default current suite' , function ( ) {
env . xit ( 'disabled spec' ) . runs ( function ( ) {
xitSpecWasRun = true ;
} ) ;
env . it ( 'enabled spec' ) . runs ( function ( ) {
var foo = 'bar' ;
expect ( foo ) . toEqual ( 'bar' ) ;
} ) ;
} ) ;
suite . execute ( ) ;
expect ( xitSpecWasRun ) . toEqual ( false ) ;
} ) ;
it ( 'shouldn\'t execute specs in disabled suites' , function ( ) {
var spy = jasmine . createSpy ( ) ;
2009-06-15 06:34:29 +00:00
var disabledSuite = env . xdescribe ( 'a disabled suite' , function ( ) {
2009-06-15 06:41:14 +00:00
env . it ( 'enabled spec, but should not be run' , function ( ) {
2009-05-29 03:02:15 +00:00
spy ( ) ;
} ) ;
} ) ;
disabledSuite . execute ( ) ;
expect ( spy ) . wasNotCalled ( ) ;
} ) ;
2009-06-15 06:34:29 +00:00
it ( '#explodes should throw an exception when it is called inside a spec' , function ( ) {
var exceptionMessage = false ;
2009-06-15 06:41:14 +00:00
var anotherSuite = env . describe ( 'Spec' , function ( ) {
env . it ( 'plodes' , function ( ) {
2009-06-15 06:34:29 +00:00
try {
2009-06-15 06:41:14 +00:00
this . explodes ( ) ;
2009-06-15 06:34:29 +00:00
}
catch ( e ) {
exceptionMessage = e ;
}
expect ( exceptionMessage ) . toNotEqual ( false ) ;
} ) ;
} ) ;
2009-06-15 06:41:14 +00:00
anotherSuite . execute ( ) ;
2009-06-15 06:34:29 +00:00
expect ( exceptionMessage ) . toEqual ( 'explodes function should not have been called' ) ;
} ) ;
2009-07-08 06:57:03 +00:00
it ( "should be easy to add more matchers local to a spec, suite, etc." , function ( ) {
var spec1 , spec2 , spec1Matcher , spec2Matcher ;
var suite = env . describe ( 'some suite' , function ( ) {
env . beforeEach ( function ( ) {
this . addMatchers ( { matcherForSuite : function ( expected ) {
return "matcherForSuite: actual: " + this . actual + "; expected: " + expected ;
} } ) ;
} ) ;
spec1 = env . it ( 'spec with an expectation' ) . runs ( function ( ) {
2009-07-30 05:27:11 +00:00
this . addMatchers ( { matcherForSpec : function ( expected ) {
2009-07-08 06:57:03 +00:00
return "matcherForSpec: actual: " + this . actual + "; expected: " + expected ;
} } ) ;
spec1Matcher = this . expect ( "xxx" ) ;
} ) ;
spec2 = env . it ( 'spec with failing expectation' ) . runs ( function ( ) {
spec2Matcher = this . expect ( "yyy" ) ;
} ) ;
} ) ;
suite . execute ( ) ;
expect ( spec1Matcher . matcherForSuite ( "expected" ) ) . toEqual ( "matcherForSuite: actual: xxx; expected: expected" ) ;
expect ( spec1Matcher . matcherForSpec ( "expected" ) ) . toEqual ( "matcherForSpec: actual: xxx; expected: expected" ) ;
expect ( spec2Matcher . matcherForSuite ( "expected" ) ) . toEqual ( "matcherForSuite: actual: yyy; expected: expected" ) ;
2009-11-26 16:12:06 +00:00
expect ( spec2Matcher . matcherForSpec ) . toBe ( jasmine . undefined ) ;
2009-07-08 06:57:03 +00:00
} ) ;
2009-05-29 03:02:15 +00:00
} ) ;