Sleipnir is a BDD testing framework for Swift that allows writing tests in a specification style. It avoids using XCTest and instead provides matchers and syntax inspired by RSpec to make test code read like specifications of behavior. Tests can be run from the command line. Sleipnir supports focus/pending examples, setup/teardown blocks, shared example groups, and matchers for assertions on values, collections, and strings.

1. Sleipnir
BDD style testing for Swift

2. Who we are
• Mobile team at railsware.com
• Open source fans railsware.github.io/

3. Outline
• What is BDD
• Testing in Swift - XCTest vs BDD style
• What Sleipnir is
• How to use it
• Questions

4. BDD

5. BDD
Behavior Driven Development

6. BDD
Behavior Driven Development
• BDD specifies that tests of any unit of software should be
specified in terms of the desired behaviour of the unit.
(from Wiki)
!
• BDD is all about specifications

7. BDD
describe("Calculator") {
!
describe("#add") {
!
it("returns the sum of its arguments") {
expect(Calculator().add(1, 2)).to(equal(3))
}
}
}

8. Testing in Swift

9. Testing in Swift - XCTest
class BookTest : XCTestCase {
func testPersonHasName() {
let person = Person(name: "John Doe”)
!
XCTAssertNotNil(person.name, "name should not be nil")
XCTAssertEqual(person.name, "John Doe", "incorrect name")
}
}

10. Testing in Swift - XCTest
class BookTest : XCTestCase {
func testPersonHasName() {
let person = Person(name: "John Doe”)
!
XCTAssertNotNil(person.name, "name should not be nil")
XCTAssertEqual(person.name, "John Doe", "incorrect name")
}
}
Does not specify behavior of the `Person` class

11. Testing in Swift - BDD
class PersonSpec : SleipnirSpec {
var personSpec = describe("Person") {
let person = Person(name: "John Doe")
context("name") {
it("should not be nil") {
expect(person.name).toNot(beNil())
}
it("should be correct") {
expect(person.name).to(equal("John Doe"))
}
}
}
}

12. Testing in Swift - BDD
Test code is a specification of a class:
• Person name should not be nil
• Person name should be correct

13. Introducing Sleipnir
https://github.com/railsware/Sleipnir

14. What Sleipnir is
Mythological steed of Odin, Norse God

15. What Sleipnir is
BDD-style framework for Swift

16. What Sleipnir is
class HorseSpec : SleipnirSpec {
var spec = describe("Horse") {
context("usual") {
it("is not awesome") {
let usualHorse = UsualHorse()
expect(usualHorse.legsCount).to(equal(4))
usualHorse.isAwesome.should.beFalse()
}
}
context("Sleipnir") {
it("is awesome") {
let sleipnirHorse = Sleipnir()
expect(sleipnirHorse.legsCount).to(equal(8))
sleipnirHorse.isAwesome.should.beTrue()
}
}
}
}

17. Core principles
• Not using XCTest
• Pure Swift BDD testing framework
• Command line output
• Seeded random tests invocation

18. How to use it

19. Running specs
1. Create a test target in Xcode
2. Invoke Runner.run() method in main.swift
3. Run test target

20. Running specs
Running With Random Seed: 7197
!
...F......
!
!
FAILURE Some spec should pass:
/Path/To/Your/Specs/SomeSpec.swift:27 Expected <1> to equal <3>
!
!
Finished in 0.0102 seconds
!
10 examples, 1 failures

21. Setup/Teardown blocks
• beforeEach { }
• afterEach { }
• beforeAll { }
• afterAll { }

22. Setup/Teardown blocks
let someSpec = describe("Some spec") {
var someArray: [Int]?
!
beforeEach {
someArray = [1, 2, 3]
}
afterEach {
someArray = nil
}
it("should pass") {
expect(someArray).toNot(beNil())
expect(someArray).to(contain(3))
}
}

23. Focused specs
Focus means “Run only focused stuff”
Useful in a project with a lot of specs

24. Focused specs
describe("Some spec") {
fit("focused") {
// WILL RUN
}
it("not focused") {
// WILL NOT RUN
}
}

25. Focused specs
fdescribe("focused group") {
// ...
}
!
fcontext("focused group") {
// ...
}
fit("focused example") {
// ...
}

26. Pending specs
Pending means “Don’t run this stuff”
Useful to denote an example that does not pass yet

27. Pending specs
xdescribe("Pending group") {
it("will not run") {
expect(false).to(beTrue())
}
it("is pending", PENDING)
}
Running With Random Seed: 2428
!
...P.......
!
PENDING Pending group is pending
!
!
Finished in 0.0062 seconds
!
11 examples, 0 failures, 1 pending

28. Shared example groups
Useful for extracting common specs
Allow to run same specs in different context

29. Shared example groups
sharedExamplesFor("some awesome stuff") {
(sharedContext : SharedContext) in
var stuff: Stuff?
beforeEach {
stuff = sharedContext()["stuff"] as Stuff
}
it("should be awesome") {
expect(stuff.awesome).to(beTrue())
}
}

30. Matchers
• equal
• beNil
• beFalse/beTrue
• beGreaterThan/beLessThan
expect(3).to(equal(3))
expect(3).toNot(beNil())
expect(true).to(beTrue())
expect(3).to(beGreaterThan(1))

31. Matchers on collections/strings
• contain
• beginWith/endWith
• beEmpty
expect([1,2,3]).to(contain(1,2))
expect("foobar").to(beginWith("foo"))
expect([1,2,3]).toNot(beEmpty())

32. Questions?
https://github.com/railsware/Sleipnir