Mock Method in Swift - swift

Question

I have the following ClassA and ClassB in swift:
protocol ClassBProtocol {
func doSomething(
completionHandler: #escaping (
ClassBProtocol?,
Error?
) -> Void
)
}
class ClassB: ClassBProtocol
{
init(key: String) {
self.key = key
}
func doSomething(
completionHandler: #escaping (
ClassBProtocol?,
Error?
) -> Void
) {
// Does some network requests and if it was successful does the following:
completionHandler(ClassB(), nil)
}
}
public class ClassA: ClassAProtocol {
static var instance: ClassA? = nil
static let initQueue = DispatchQueue(label: "queue")
static let semaphore = DispatchSemaphore(value: 1)
#objc public static func getSomething(
withKey key: String,
completionHandler: #escaping (ClassA?, Error?) -> Void
) {
ClassA.initQueue.async {
ClassA.semaphore.wait()
DispatchQueue.main.async {
if let objectA = ClassA.instance {
ClassA.semaphore.signal()
completionHandler(objectA, nil)
return
}
let objectB = ClassB(withKey: key)
objectB.doSomething { response, error in
guard let response = response else {
ClassA.semaphore.signal()
completionHandler(nil, error)
return
}
let objectA = ClassA()
ClassA.instance = objectA
ClassA.semaphore.signal()
completionHandler(objectA, nil)
}
}
}
}
}
And the following test case to test ClassA.getSomething() and ensure a race condition does not happen:
func testgetSomethingReturnsSameInstance() {
let expectation1 = self.expectation(description: "getSomething 1 completed")
let expectation2 = self.expectation(description: "getSomething 2 completed")
let expectation3 = self.expectation(description: "getSomething 3 completed")
var client1: ClassA?
var client2: ClassA?
var client3: ClassA?
ClassA.getSomething() { (client, error) in
client1 = client
expectation1.fulfill()
}
ClassA.getSomething() { (client, error) in
client2 = client
expectation2.fulfill()
}
ClassA.getSomething() { (client, error) in
client3 = client
expectation3.fulfill()
}
waitForExpectations(timeout: 10) { (error) in
XCTAssertEqual(client1, client2)
XCTAssertEqual(client2, client3)
XCTAssertEqual(client1, client3)
}
}
The doSomething in ClassB sends a network request and will return an object. I need to mock this method to do the following:
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
completionHandler(response: ClassB(), error: nil)
}
But couldn't find any way to do it. Does anyone have a solution for this?

Answer 1

It'd be easier to understand your code if you used reasonable names. I suspect ClassB wraps an API, and ClassA holds some value (like a database) that you want to fetch from the API exactly once. So let's rename ClassBProtocol and ClassB accordingly:
protocol API {
func fetch(completion: #escaping (Result<Data, Error>) -> Void)
}
class LiveAPI: API {
let key: String
init(key: String) {
self.key = key
}
func fetch(completion: #escaping (Result<Data, Error>) -> Void) {
// Do some network requests to get the real `Data` or a real error, and then:
completion(.success(Data()))
// or in case of error:
// completion(.failure(error))
}
}
Then let's rename ClassA to Database and put getSomething on hold, leaving just this:
public class Database: NSObject {
private init(data: Data) {
// construct myself from the raw data
}
}
Now, how to fetch the database exactly once, the first time it's requested?
The general advice from Apple engineers is to avoid potentially blocking operations in blocks you send to Dispatch queues. In this case, semaphore.wait() is a potentially blocking operation.
Furthermore, synchronous code is easier to test than asynchronous code, but you've made everything asynchronous. The first thing your getSomething does is an async dispatch, and a significant chunk of state (the set of pending completion handlers) is hidden away in Dispatch data structures that we cannot access.
Instead of using semaphore and initQueue, let's manually and synchronously track the completion handlers that need to be called when the database has been fetched. There are three states:
We haven't started fetching the database.
We've started fetching the database, but it's still downloading and we have one or more completion handlers to be called when it's finished.
We've finished fetching the database and there are no completion handlers to call.
We'll store these three mutually-exclusive states using an enum, and guard access to the stored state using a DispatchQueue:
extension Database {
// All access to q_fetchState must be on q!
private static var q_fetchState: FetchState = .unstarted
private static let q = DispatchQueue(label: "initQueue")
private typealias Completion = (Result<Database, Error>) -> Void
private enum FetchState {
case unstarted
case started([Completion])
case done(Result<Database, Error>)
}
}
When asked for the database, we examine the state and act appropriately:
extension Database {
#objc
public static func getDatabase(
apiKey key: String,
completion objc_completion: #escaping (Database?, Error?) -> Void
) {
let completion: Completion = {
switch $0 {
case .failure(let error): objc_completion(nil, error)
case .success(let database): objc_completion(database, nil)
}
}
q.sync {
switch q_fetchState {
case .unstarted:
q_fetchState = .started([completion])
DispatchQueue.main.async {
let api = LiveAPI(key: key)
api.fetch { result in
let result = result.map { Database(data: $0) }
let completions = q.sync {
guard case .started(let completions) = q_fetchState else {
preconditionFailure()
}
q_fetchState = .done(result)
return completions
}
for completion in completions {
completion(result)
}
}
}
case .started(let array):
q_fetchState = .started(array + [completion])
case .done(let result):
DispatchQueue.main.async {
completion(result)
}
}
}
}
}
Notice that there are no blocking operations performed under q, so it's safe and efficient to use q.sync instead of q.async, and we'll see later that it makes the function more testable.
Okay, now back to your actual question, which I interpret as: How do we mock the API? Since we already have an API protocol, we want to make getDatabase generic over a type conforming to API, and make it take an instance of that type:
extension Database {
static func getDatabase<A: API>(
api: A,
completion: #escaping (Result<Database, Error>) -> Void
) {
q.sync {
switch q_fetchState {
case .unstarted:
q_fetchState = .started([completion])
DispatchQueue.main.async {
api.fetch { result in
let result = result.map { Database(data: $0) }
let completions = q.sync {
guard case .started(let completions) = q_fetchState else {
preconditionFailure()
}
q_fetchState = .done(result)
return completions
}
for completion in completions {
completion(result)
}
}
}
case .started(let array):
q_fetchState = .started(array + [completion])
case .done(let result):
DispatchQueue.main.async {
completion(result)
}
}
}
}
}
These changes mean the method is no longer compatible with Objective-C. So let's add an overload with the old, Objective-C-compatible signature:
#objc
public static func getDatabase(
apiKey key: String,
completion: #escaping (Database?, Error?) -> Void
) {
return getDatabase(api: LiveAPI(key: key)) {
switch $0 {
case .failure(let error): completion(nil, error)
case .success(let database): completion(database, nil)
}
}
}
}
Now we're ready to write a mock implementation of API. Based on the code you posted, it would look like this:
struct BadTestAPI: API {
let result: Result<Data, Error>
func fetch(completion: #escaping (Result<Data, Error>) -> Void) {
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
completion(result)
}
}
}
But I don't like this implementation for at least three reasons:
It hardcodes a 0.5 second delay. Yuck. We want test cases to run as fast as possible!
It doesn't make it easy to verify that fetch is only called once.
It doesn't let us control more precisely when it calls the completion handler.
Instead, let's write the mock implementation this way:
class TestAPI: API {
let ex = XCTestExpectation(description: "api.fetch called")
var completion: ((Result<Data, Error>) -> Void)? = nil
func fetch(completion: #escaping (Result<Data, Error>) -> Void) {
XCTAssertNil(self.completion)
self.completion = completion
ex.fulfill()
}
}
Now we can write the test case to use this implementation:
final class TestDatabase: XCTestCase {
func testGetDatabaseReturnsSameInstance() {
class Record {
let ex = XCTestExpectation()
var database: Database? = nil
}
let api = TestAPI()
let records = [Record(), Record(), Record()]
XCTAssertNil(api.completion)
for record in records {
Database.getDatabase(api: api) {
XCTAssertNil(record.database)
record.database = try! $0.get()
record.ex.fulfill()
}
}
self.wait(for: [api.ex], timeout: 10)
for record in records {
XCTAssertNil(record.database)
}
api.completion!(.success(Data()))
wait(for: records.map(\.ex), timeout: 10)
XCTAssertNotNil(records[0].database)
for record in records.dropFirst() {
XCTAssertEqual(record.database, records[0].database)
}
}
}
Here are some things this test case verifies:
api.fetch is not called before Database.getDatabase.
api.fetch is only called once.
No completion handler is called more than once.
The getDatabase completion handlers are called after the api.fetch completion handler.