v4.x
Getting Started
In-Depth
Mocking
Continuous Integration
BDD
Global Callbacks
Global callbacks affect the execution of the entire test bundle CFC and all of its suites and specs.
beforeAll()
Executes once before all specs for the entire test bundle CFC. A great place to initialize the environment the bundle needs for testing.
1
component{
2
​
3
function beforeAll(){
4
ORMSessionClear();
5
structClear( request );
6
7
// Prepare jwt driver to use cache instead of db for easier mocking
8
variables.jwt.getSettings().jwt.tokenStorage.driver = "cachebox";
9
variables.jwt.getSettings().jwt.tokenStorage.properties = { cacheName : "default" };
10
​
11
// Logout just in case
12
variables.securityService.logout();
13
}
14
​
15
}
Copied!
afterAll()
Executes once after all specs for the entire test bundle CFC. A great place to teardown the environment the bundle needed for testing.
1
component{
2
​
3
function afterAll(){
4
variables.securityService.logout();
5
directoryDelete( "/tests/tmp", true );
6
}
7
​
8
}
Copied!
run( testResults, testBox )
Executes once so it can capture all your
describe and it blocks so they can be executed by a TestBox runner. 1
function run( testResults, testbox ){
2
​
3
describe("A Spec", function(){
4
5
});
6
​
7
}
Copied!
You can find the API docs for
testbox and the testResults arguments here: https://s3.amazonaws.com/apidocs.ortussolutions.com/testbox/current/​Suite Callbacks
The following callbacks influence the execution of specification methods:
it(), then(). The great flexibility of the BDD approach is that it allows you to nest describe, feature, story, given, scenario, when suite blocks to create very human readable and organized documentation for your tests. Each suite block can have its own life-cycle methods as well. Not only that, if they are nested, TestBox will walk the tree and call each beforeEach() and afterEach() in the order you declare them.TestBox will walk down the tree (from the outermost suite) for
beforeEach() operations and out of the tree (from the innermost suite) for afterEach() operations.beforeEach( body, data )
Executes before every single spec in a single suite block and receives the currently executing spec and any data you want to bind the specification with. The
body is a closure/lambda that will fire and the data argument is a way to bind the life-cycle method with a struct of data that can flow down to specs.The
body closure will receive have the following signature:1
function( currentSpec, data ){
2
​
3
}
4
​
5
(currentSpec, data ) => {}
Copied!
afterEach( body, data )
Executes after every single spec in a single suite block and receives the currently executing spec and any data you want to bind the specification with. The
body is a closure/lambda that will fire and the data argument is a way to bind the life-cycle method with a struct of data that can flow down to specs.The
body closure will receive have the following signature:1
function( currentSpec, data ){
2
​
3
}
4
​
5
(currentSpec, data ) => {}
Copied!
Here are some examples:
1
component{
2
​
3
function run( testResults, testBox ){
4
describe("A Spec", function(){
5
​
6
beforeEach( function( currentSpec, data ){
7
// before each spec in this suite
8
});
9
​
10
afterEach( function( currentSpec, data ){
11
// after each spec in this suite
12
});
13
​
14
describe("A nested suite", function(){
15
​
16
// my parent's aroundEach()
17
​
18
beforeEach( ( currentSpec, data ) => {
19
// before each spec in this suite + my parent's beforeEach()
20
});
21
​
22
afterEach( ( currentSpec, data ) => {
23
// after each spec in this suite + my parent's afterEach()
24
});
25
​
26
});
27
​
28
});
29
​
30
describe("A second spec", function(){
31
​
32
beforeEach( function( currentSpec, data ){
33
// before each spec in this suite, separate from the two other ones
34
});
35
​
36
afterEach( function( currentSpec, data ){
37
// after each spec in this suite, separate from the two other ones
38
});
39
​
40
});
41
}
42
}
Copied!
aroundEach( body, data )
Executes around the executing spec so you can provide code that will surround the execution of the spec. It's like combining
before and after in a single operation. The body is a closure/lambda that will fire and the data argument is a way to bind the life-cycle method with a struct of data that can flow down to specs. This is the only way you can use CFML constructs that wrap around code like: try/catch, transaction, for, while, etc.The
body closure will receive have the following signature:1
function( spec, suite, data ){
2
​
3
}
4
​
5
(spec, suite, data) => {}
Copied!
The
spec is the currently executing specification, the suite is the suite this life-cycle is embedded in and data is the data binding, if any.Here is an example:
1
component{
2
​
3
function run( testResults, testBox ){
4
describe("A Spec", function(){
5
​
6
aroundEach( function( spec, suite, data ){
7
ormClearSession();
8
ormCloseSession();
9
try {
10
// Make sure we always rollback
11
transaction {
12
arguments.spec.body();
13
}
14
} catch ( any e ) {
15
transactionRollback();
16
rethrow;
17
}
18
});
19
​
20
describe("A nested suite", function(){
21
​
22
// my parent's aroundEach()
23
​
24
beforeEach( function( currentSpec, data ){
25
// before each spec in this suite + my parent's beforeEach()
26
});
27
​
28
afterEach( function( currentSpec, data ){
29
// after each spec in this suite + my parent's afterEach()
30
});
31
​
32
});
33
​
34
});
35
}
36
}
Copied!
Life-Cycle Data Binding
You can pass in an argument called
data , which is a struct of dynamic data, to all life-cycle methods. This is useful when creating dynamic suites and specifications. This data will then be passed into the executing body for each life-cycle method for you.1
beforeEach(
2
data = { mydata="luis" },
3
body = function( currentSpec, data ){
4
// The arguments.data is binded via the `data` snapshot above.
5
data.myData == "luis";
6
}
7
);
Copied!
Here is a typical example:
1
describe( "Ability to bind data to life-cycle methods", function(){
2
​
3
var data = [
4
"spec1",
5
"spec2"
6
];
7
​
8
for( var thisData in data ){
9
describe( "Trying #thisData#", function(){
10
​
11
beforeEach(
12
data : { myData = thisData },
13
body : function( currentSpec, data ){
14
targetData = arguments.data.myData;
15
});
16
​
17
it(
18
title : "should account for life-cycle data binding",
19
data : { myData = thisData },
20
body : function( data ){
21
expect( targetData ).toBe( data.mydata );
22
}
23
);
24
​
25
afterEach(
26
data : { myData = thisData },
27
body : function( currentSpec, data ){
28
targetData = arguments.data.myData;
29
});
30
});
31
}
32
​
33
for( var thisData in data ){
34
​
35
describe( "Trying around life-cycles with #thisData#", function(){
36
​
37
aroundEach(
38
data : { myData = thisData },
39
body : function( spec, suite, data ){
40
targetData = arguments.data.myData;
41
arguments.spec.body( data=arguments.spec.data );
42
});
43
​
44
it(
45
title : "should account for life-cycle data binding",
46
data : { myData = thisData },
47
body : function( data ){
48
expect( targetData ).toBe( data.mydata );
49
});
50
​
51
});
52
​
53
}
54
});
Copied!
Last modified 11mo ago