Quick Intro to Test Driven Development (TDD) in Swift

Test or GoFishing

Paul Ardeleanu
@pardel
A guide on how to write better Swift for iOS

TechFest Bucharest, Sept 2018 @pardel
Test Driven Development



TDD
according to Wikipedia
“Test-driven development (TDD) is a software development process
that relies on the repetition of a very short development cycle:
requirements are turned into very specific test cases, then the
software is improved to pass the new tests, only. This is opposed
to software development that allows software to be added that is not
proven to meet requirements.”
https://en.wikipedia.org/wiki/Test-driven_development

Why use TDD?


Behaviour Driven Development



BDD
according to Wikipedia
"combines the general techniques and principles of TDD with ideas
from domain-driven design and object-oriented analysis and design
to provide software development and management teams with
shared tools and a shared process to collaborate on software
development."
https://en.wikipedia.org/wiki/Behavior-driven_development

TDD vs BDD


To Be Determined


Quick But Gentle
Introduction to TDD



TDD lifecycle
Feature, Red, Green, Refactor
Pick a feature to implement
making sure it’s a small enough unit.
FEATURE
Change any of the existing code
making sure ALL tests are passing.
REFACTOR
Write a failing test.
Stop as soon as you get a failure.
RED
Write code to pass the test.
Write as little code as possible.
GREENL (
)


TDD lifecycle
Feature, Red, Green, Refactor
New
feature
create test
enough code to
make it pass
successful
test execution
No
anything to
refactor
Yes
Yes
refactoring
No
Ya Ain’t Gonna Need It


Testing pyramid
Unit Tests
Integration Tests
UI Tests

Testing in iOS



Testing in iOS
XCTest - since Xcode 5

Playgrounds


struct Task {
}
class TaskTests: XCTestCase {
func testCanCreateATask() {
_ = Task()
}
}
TaskTests.defaultTestSuite.run()

struct Task {
}
_ = Task()
}
func testTaskMustHaveANonBlankName() {
let task = Task(name: "")
XCTAssertNil(task)
}
}

struct Task {
var name: String
}
_ = Task()
}
XCTAssertNil(task)
}
}

struct Task {
var name: String
}
_ = Task()
}
XCTAssertNil(task)
}
}
init?(name: String) {
if name.lengthOfBytes(using: .utf8) == 0 {
return nil
}
self.name = name
}

struct Task {
var name: String
return nil
}
self.name = name
}
}
_ = Task(name: UUID().uuidString)
}
XCTAssertNil(task)
}
}

struct Task {
var name: String
return nil
}
self.name = name
}
}
_ = Task(name: UUID().uuidString)
}
XCTAssertNil(task)
}
}
let name = UUID().uuidString
let task = Task(name: name)
XCTAssertEqual(task?.name, name)

struct Task {
var name: String
return nil
}
self.name = name
}
}
}
XCTAssertNil(task)
}
}

struct Task {
var name: String
// if name.lengthOfBytes(using: .utf8) == 0 {
// return nil
// }
// self.name = name
}
}
}
XCTAssertNil(task)
}
}


Moving to an
Xcode project


Object Factories

enum TaskFactory {
static var active: Task {
return Task(name: UUID().uuidString)!
}
static var completed: Task {
var task = Task(name: UUID().uuidString)!
task.complete()
return task
}
}
class TaskFactoryTests: XCTestCase {
func testActiveTask() {
let task = TaskFactory.active
XCTAssertTrue(task.isActive)
}
func testCompletedTask() {
let task = TaskFactory.completed
XCTAssertFalse(task.isActive)
}
}

func testActiveTasksDontIncludeCompletedTask() {
let startTaskCount = taskManager.activeTasks.count
taskManager.add(task: TaskFactory.completed)
XCTAssertEqual(taskManager.activeTasks.count, startTaskCount)
}
func testCompletedTasksDontIncludeActiveTask() {
let startTaskCount = taskManager.completedTasks.count
taskManager.add(task: TaskFactory.active )
XCTAssertEqual(taskManager.completedTasks.count, startTaskCount)
}

taskManager.add(task: TaskFactory.completed)
}
taskManager.add(task: TaskFactory.active)
}


3rd Party Libraries

class TaskManager {
private var tasks = [Task]()
public var activeTasks: [Task] {
do {
let predicate = NSPredicate(format: "completedAt == nil")
let items = try Realm().objects(Task.self).filter(predicate)
return Array(items)
} catch {
return [Task]()
}
}
public var completedTasks: [Task] {
do {
let predicate = NSPredicate(format: "completedAt != nil")
let items = try Realm().objects(Task.self).filter(predicate)
return Array(items)
} catch {
return [Task]()
}
}
…
}

class TaskManagerTests: XCTestCase {
var taskManager: TaskManager!
override func setUp() {
super.setUp()
taskManager = TaskManager()
}
…
}

super.setUp()
Realm.Configuration.defaultConfiguration =
Realm.Configuration(inMemoryIdentifier: "Toddledoo")
}
…
}

super.setUp()
Realm.Configuration.defaultConfiguration =
Realm.Configuration(inMemoryIdentifier: UUID().uuidString)
}
…
}

UI tests


class TasksViewControllerTests: XCTestCase {
let storyboard = UIStoryboard(name: "Main", bundle: nil)
var vc: TasksViewController?
super.setUp()
vc = storyboard.instantiateViewController(withIdentifier: "TasksViewController") as? TasksViewController
vc?.loadViewIfNeeded()
}
func testSetup() {
XCTAssertNotNil(vc)
XCTAssertEqual(vc?.isViewLoaded, true)
}
func testIsInitialViewController() {
let nav = storyboard.instantiateInitialViewController() as? UINavigationController
XCTAssertNotNil(nav)
XCTAssertEqual(nav?.viewControllers.count, 1)
XCTAssertNotNil(nav?.viewControllers.first as? TasksViewController)
}
func testHasTitle() {
XCTAssertEqual(vc?.title, "Toddledoo")
}
}

}

}
let storyboard = UIStoryboard(name: "Main", bundle: nil)
var vc: TasksViewController?
super.setUp()
vc = storyboard.instantiateViewController(withIdentifier: "TasksViewController") as? TasksViewController
vc?.loadViewIfNeeded()
}
func testSetup() {
XCTAssertNotNil(vc)
XCTAssertEqual(vc?.isViewLoaded, true)
}

...
}
func testHasTableView() {
XCTAssertNotNil(vc?.tableView)
XCTAssertNotNil(vc?.tableView.superview)
XCTAssertEqual(vc?.tableView.superview, vc?.view)
}
func testTableViewCoversWholeView() {
XCTAssertNotNil(vc?.view)
XCTAssertEqual(vc?.view.bounds, vc?.tableView.frame)
}
let hasTopConstraint = vc?.view.constraints.contains(where: { constraint -> Bool in
return ((constraint.firstItem as? UITableView) == vc?.tableView) &&
(constraint.firstAnchor == vc?.tableView.topAnchor) &&
((constraint.secondItem as? UILayoutGuide) == vc?.view.safeAreaLayoutGuide) &&
(constraint.secondAnchor == vc?.view.safeAreaLayoutGuide.topAnchor) &&
(constraint.relation == .equal) &&
constraint.multiplier == 1.0 &&
constraint.constant == 0 &&
constraint.isActive == true
})
XCTAssert(hasTopConstraint ?? false)
}

}
XCTAssert(vc?.view.constraints.contains(where: { constraint -> Bool in
(constraint.firstAnchor == vc?.tableView.topAnchor) &&
(constraint.secondAnchor == vc?.view.safeAreaLayoutGuide.topAnchor) &&
constraint.multiplier == 1.0 && constraint.constant == 0 && constraint.isActive == true
}) ?? false)
(constraint.firstAnchor == vc?.tableView.bottomAnchor) &&
(constraint.secondAnchor == vc?.view.safeAreaLayoutGuide.bottomAnchor) &&
}) ?? false)
(constraint.firstAnchor == vc?.tableView.leadingAnchor) &&
(constraint.secondAnchor == vc?.view.safeAreaLayoutGuide.leadingAnchor) &&
}) ?? false)
(constraint.firstAnchor == vc?.tableView.trailingAnchor) &&
(constraint.secondAnchor == vc?.view.safeAreaLayoutGuide.trailingAnchor) &&
}) ?? false)
}

Continuous Integration



macOS Server

Some tips



Pick good test names
test_init_takesTitleAndDescription()
test_ValidAccountName_InvalidAccountNumber_ValidSortCode_CurrentAccoun
t_OneOwner_CanNotBeInstantiated()


Pick good names
SUT
func testLogoutCallsDelegateMethod() {
// Given
guard let sut = sut else {
XCTFail("Could not get system under test")
return
}
// When
delegateStatus = .noneCalled
sut.logout()
// Then
XCTAssertTrue(delegateStatus == .didLogoutCalled, "delegate method was not called")
}


No magic numbers
UUID().uuidString
// Swift 4.2
Int.random(in: 1..<5)
Float.random(in: 1..<10)
Double.random(in: 1...100)
CGFloat.random(in: 1...1000)
Bool.random()
anArray.shuffle()
anArray.shuffled()
anArray.randomElement()


No magic numbers
XCTAssertTrue(taskManager.add(task: TaskFactory.completed))
}
XCTAssertTrue(taskManager.add(task: TaskFactory.active))
}


Input & output in one place
XCTAssertNotNil(task)
}


Third party libraries


Test EVERYTHING


Be very specific in your tests
We wanted flying cars


App Architecture
MVC, MVVM, MVVM-P, Viper, etc.
https://www.objc.io/books/app-architecture/


BDD
Quick & Nimble
import Quick
import Nimble
class TableOfContentsSpec: QuickSpec {
override func spec() {
describe("the 'Documentation' directory") {
it("has everything you need to get started") {
let sections = Directory("Documentation").sections
expect(sections).to(contain("Organized Tests with Quick Examples and Example Groups"))
expect(sections).to(contain("Installing Quick"))
}
context("if it doesn't have what you're looking for") {
it("needs to be updated") {
let you = You(awesome: true)
expect{you.submittedAnIssue}.toEventually(beTruthy())
}
}
}
}
}


FitNesse
http://fitnesse.org
package fitnesse.slim.test;
public class ShouldIBuyMilk {
private int dollars;
private int pints;
private boolean creditCard;
public void setCashInWallet(int dollars) {
this.dollars = dollars;
}
public void setPintsOfMilkRemaining(int pints) {
this.pints = pints;
}
public void setCreditCard(String valid) {
creditCard = "yes".equals(valid);
}
public String goToStore() {
return (pints == 0 && (dollars > 2 || creditCard)) ? "yes" : "no";
}
// The following functions are optional. If they aren't declared they'll be ignored.
public void execute() {
}
public void reset() {
}
public void table(List<List<String>> table) {
}
public void beginTable() {
}
public void endTable() {
}
}

https://m.pardel.net

h24.io /techfest

Thank you!
paul@codica.eu
@pardel
codica.eu

Quick Intro to Test Driven Development (TDD) in Swift

Recomendados

Recomendados

Más contenido relacionado

La actualidad más candente

La actualidad más candente (20)

Similar a Quick Intro to Test Driven Development (TDD) in Swift

Similar a Quick Intro to Test Driven Development (TDD) in Swift (20)

Más de Paul Ardeleanu

Más de Paul Ardeleanu (19)

Último

Último (20)

Quick Intro to Test Driven Development (TDD) in Swift