Just Do It! ColdBox Integration Testing

Just Do It! ColdBox
Integration Testing
A V I R T U A L E X P E R I E N C E

About Me
• Javier Quintero
• Systems Engineer
• Born in Colombia => Living in
Houston, Texas
• Java and Coldfusion Developer
• Currently working for Ortus
Solutions

Content
• Introduction
• Testing Foundations
• Intro to TestBox
• BDD Testing
• ColdBox Integration Testing
• Suites and Specs
• Expectations
• Matchers
• MockBox
• Mocking Data

What are Integration Tests?
Integration testing is a level of
software testing where individual
units are combined and tested as
a group. The purpose of this level
of testing is to expose faults in the
interaction between integrated
units. Test drivers and test stubs
are used to assist in Integration
Testing.

Why this is important?
• Integration tests allow you to test
your application by covering the
real use cases.
• It’s the extension of unit testing.
• Integration testing takes a
smaller unit of unit testing and
tests their behavior as the whole.

Advantages of Integration Testing
• Tests run faster compared to end to
end tests.
• Confidence in the development
cycle is high.
• Easy to integrate with daily builds
and easy to test in development
environment.
• Tests are more reliable and easy to
isolate the failures.
• Majorly helps to build real-time use
cases during the end to end testing.

When should we test?
•Always!
• No more excuses!
• Test your code and make it
part of your development
process.

How to test your ColdBox App

> CommandBox to the rescue
• Install TestBox
• install testbox –savedev
TestBox Command Help
• testbox help
TestBox Generations
• testbox create bdd
Even Run Tests
• Testbox run

ColdBox Testing
• ColdBox has specific testing classes for
• Integration
• Event Handlers
• Interceptors
• Model Objects

Tools
ColdBox Testing
ColdBox tightly integrates to MockBox
and TestBox

TestBox
• TestBox is a next generation testing
framework for ColdFusion (CFML) that
is based on BDD (Behavior Driven
Development) for providing a clean
obvious syntax for writing tests.
• TestBox 4.0.0 released last week!
• TestBox Output Utilities
• Mocking Data

MockBox
• TestBox includes a mocking and
stubbing library called MockBox.
• No need to install a separate libary, it
is part of TestBox!
• MockBox allows you to create mock
and stub objects.

BDD
• BDD stands for behavior driven
development and is highly based on
creating specifications and
expectations of results in a readable
DSL (Domain Specifc Language).

BDD Relationship
Requirements to Integration Tests
Req 1
Req 2
Req 3
MyBDDTest

ColdBox Test Suite
ColdBox Application
templates includes a test
folder
• Collection of
• Tests
• Runners
• Automation,
resources
• Includes its own
Application.cfc

ColdBox Test Classes
* The BaseTestCase - Used for Integration Testing

Capabilities
• BaseTestCase gives you the ability to test
your ColdBox Application headlessly
• Test everything top-down: DI, AOP, Cache,
executions, etc.
• Test real requirements: Can I login, Can I
shop, Can I logout
• Tests must have the ability to talk to your
application
• Same server, mappings, orm config, etc
• You can even test relocations
• You can also test view/layout renderings

Grouping Your Tests
//tests/specs/MySpec.cfc
component extends="testbox.system.BaseSpec"{
// executes before all suites
function beforeAll(){}
// executes after all suites
function afterAll(){}
// All suites go in here
function run( testResults, testBox ){
}
}
• Suites
• Specs

Test Annotations

Describing Your Tests
function run( testResults, testBox ){
describe("A suite", function(){
it("contains spec with an awesome expectation", function(){
expect( true ).toBeTrue();
});
it("contains spec with a failure expectation", function(){
expect( true ).toBeFalse();
});
});
}
The describe() function is also aliased with the following names:
story(), feature(), scenario(), given(), when()
Suites: A test suite in TestBox is a collection of specifications that will model what
you want to test.

Specs Arguments
Full arguments list

Specs
function run(){
describe("A suite", function(){
it("contains spec with an awesome expectation", function(){
expect( true ).toBeTrue();
});
it("contains a spec with more than 1 expectation", function(){
expect( [1,2,3] ).toBeArray();
expect( [1,2,3] ).toHaveLength( 3 );
});
});
}
A spec is a declaration that will usually test your system with a requirement.
The it() function is also aliased as then()

Closure Functions
• They can execute code that is necessary to implement the test.
• CFML rules of scoping are applied to closures.
• Always use the variables scope for easy access and distinction.
function run(){
describe("A suite is a closure", function(){
c = new Calculator();
it("and so is a spec", function(){
expect( c ).toBeTypeOf( 'component' );
});
});
}

Expectactions

Expectations
• Self-concatenated strings that evaluate an
actual value to an expected value or
condition.
• expect() -> Takes in a value called the actual
value .
• expectAll() -> Takes in an array or struct
which will be the actual value.
• Concatenate the matchers.
• Multiple evaluations on a single actual value.

Matchers
Each matcher implements a comparison or evaluation of the actual value and an
expected value or condition.
function run(){
describe("The 'toBe' matcher evaluates equality", function(){
it("and has a positive case", function(){
expect( true ).toBe( true );
});
it("and has a negative case", function(){
expect( false ).notToBe( true );
});
});
describe("Collection expectations", function(){
it( "can be done easily with TestBox", function(){
expectAll( {a:2,b:4,c:6} ).toSatisfy( function(x){ return 0 == x%2; });
});
});
}

Matchers
Most common matchers
• toBeTrue( [message] ) : value to true
• toBeFalse( [message] ) : value to be false
• toBe( expected, [message] ) : Assert something is equal to each other, no case is required
• toBeWithCase( expected, [message] ) : Expects with case
• toBeNull( [message] ) : Expects the value to be null
• toBeInstanceOf( class, [message] ) : To be the class instance passed
• toMatch( regex, [message] ) : Matches a string with no case-sensitivity
• toMatchWithCase( regex, [message] ) : Matches with case-sensitivity
• toBeTypeOf( type, [message] ) : Assert the type of the incoming actual data, it uses the internal
ColdFusion isValid() function behind the scenes, type can be array, binary, boolean, component,
date, time, float, numeric, integer, query, string, struct, url, uuid plus all the ones from isValid()
• toBe({type}( [message] ) : Same as above but more readable method name. Example: .toBeStruct(),
.toBeArray()
• toBeEmpty( [message] ) : Tests if an array or struct or string or query is empty
• toHaveKey( key, [message] ) : Tests the existence of one key in a structure or hash map
Each matcher implements a comparison or evaluation of the actual value and an expected value or
condition.

Matchers
Most common matchers
• toHaveDeepKey( key, [message] ) : Assert that a given key exists in the passed in struct by
searching the entire nested structure
• toHaveLength( length, [message] ) : Assert the size of a given string, array, structure or query
• toThrow( [type], [regex], [message] );
• toBeCloseTo( expected, delta, [datepart], [message] ) : Can be used to approximate numbers or
dates according to the expected and delta arguments. For date ranges use the datepart values.
• toBeBetween( min, max, [message] ) : Assert that the passed in actual number or date is between
the passed in min and max values
• toInclude( needle, [message] ) : Assert that the given "needle" argument exists in the incoming
string or array with no case-sensitivity, needle in a haystack anyone?
• toIncludeWithCase( needle, [message] ) : Assert that the given "needle" argument exists in the
incoming string or array with case-sensitivity, needle in a haystack anyone?
• toBeGT( target, [message] ) : Assert that the actual value is greater than the target value
• toBeGTE( target, [message] ) : Assert that the actual value is greater than or equal the target value
• toBeLT( target, [message] ) : Assert that the actual value is less than the target value
• toBeLTE( target, [message] ) : Assert that the actual value is less than or equal the target value
The complete list can be found in the official API Docs site
http://apidocs.ortussolutions.com/testbox/current

Custom Matchers
• Create your own matcher if you don’t find it in the Docs
boolean function MyMatcher( required expectation, args={} )
boolean function reallyFalse( expectation, args={} ){
expectation.message = (
structKeyExists( args, "message" ) ? args.message :
”[#expectation.actual#] is not really false"
);
if( expectation.isNot )
return ( expectation.actual eq true );
else
return ( expectation.actual eq false );
}
}

The setup() Method
• This is how ColdBox simulates a request
• Must be called in a setup() or beforeEach()
context
• If not, everything looks like the same request
function run(){
describe( "Settings Suite", function(){
beforeEach( function( currentSpec ){
setup();
} );
});
}
Setup()
Test1
Test3
Test4
Test2

The execute() Method
The execute() method is your way of making requests in to your
ColdBox application.
Create your test or spec
Set FORM/URL scopes or Headers to simulate
incoming data
Execute the event, it returns an event object (Request
Context)
Do your expectations/assertions

The execute() Method
ican take the following parameters:

The Handler To Test
component extends="coldbox.system.EventHandler"{
// Default Action
function index( event, rc, prc ){
prc.welcomeMessage = "Welcome to ITB 2020!";
event.setView( "main/index” );
}
// Do something
function doSomething( event, rc, prc ){
relocate( "main.index” );
}
}
Main handler

The Integration Test
function run(){
describe( "Main Handler", function(){
beforeEach(function( currentSpec ){
setup();
});
it( "+homepage renders", function(){
var event = execute( event="main.index", renderResults=true );
expect( event.getValue( name="welcomemessage", private=true ) ).toBe( "Welcome to ITB 2020!" );
});
it( "+doSomething relocates", function(){
var event = execute( event="main.doSomething" );
expect(event.getValue( "relocate_event", "" ) ).toBe( "main.index" );
});
});
}
Main handler

Mocking Data

Mocking Data
• MockDataCFC dependency included since
version 4.x
• Generate fake data as JSON REST service, a
ColdBox Module or a simple CFC Service API
• MockDataCFC allows you to define the
return data model in a very deterministic and
simple modeling DSL.

Mocking Types
MockDataCFC supports the following types
• age: Generates a random "adult" age of 18 to 75.
• all_age: Generates a random age of 1 to 100.
• autoincrement: Returns an incremented index starting from 1
• baconlorem: Returns bacon lorem ipsum text. If used as baconlorem:N, returns N paragraphs. If
used as baconlorem:X Y, returns a random number of paragraphs between X and Y.
• date: Generates a random date
• datetime: Generates a random date and time value
• email: Generates a random email.
• fname: Generates a random first name.
• imageurl : Generates a random image URL with a random protocol
• imageurl_http : Generates a random image URL with http only protocol
• imageurl_https : Generates a random image URL with https only protocol
• ipaddress : Generates an ipv4 address
• name: Generates a random name.
• lname: Generates a random last name.
• lorem: Returns lorem ipsum text. If used as lorem:N, returns N paragraphs. If used as lorem:X Y,
returns a random number of paragraphs between X and Y.
• num: By default, a number from 1 to 10. You can also use the form num:X for a random number
between 1 and X. Or num:X Y for a random number between X and Y.

Mocking Types
More types…
• One of:X y: Requires you to pass N values after it delimited by a colon. Example: oneof:male:
female. Will return a random value from that list.
• rnd:N, rand:N, rnd:X y, rand:X y : Generate random numbers with a specific range or range cap.
• sentence: Generates a sentences. If used as sentence:N, returns N sentences. If used as
sentence:X Y, returns a random number of sentences beetween X and Y.
• ssn: Generates a random Social Security number.
• string: Generates a random string of length 10 by default. You can increase the length by passing it
string:length.
• tel: Generates a random (American) telephone number.
• uuid: Generates a random UUID
• url : Generates a random URL with a random protocol
• url_http : Generates a random URL with http only protocol
• url_https : Generates a random URL with https only protocol
• website : Generates a random website with random protocol
• website_http : Generates a random website, http only protocol
• website_https : Generates a random website, https only protocol
• words: Generates a single word. If used as word:N, returns N words. If used as words:X Y, returns a
random number of words between X and Y.

Mocking Examples

Tests Output Utilities
Produce output from your tests

Let’s Put All Together

Create The Integration Test
• Let’s use Commandbox to generate the
integration tests for us.
• coldbox create integration-test handler=main actions=show,create,delete

Life Cycle Methods

Test suite and specs

Let’s create our integration test
for the show action

for the create action

for the delete action

Run Your Tests

Gracias!

Javier Quintero
Web Developer
Ortus Solutions, Corp
@xavikintero
@ortussolutions

Just Do It! ColdBox Integration Testing

Recommended

More Related Content

What's hot (19)

Similar to Just Do It! ColdBox Integration Testing (20)

More from Ortus Solutions, Corp (20)

Recently uploaded (20)

Just Do It! ColdBox Integration Testing