Swiftでクロージャを使ったテスト用モック関数の実装方法を徹底解説

{ (引数) -> 戻り値の型 in
    実行されるコード
}

let greetClosure = { (name: String) -> String in
    return "Hello, \(name)!"
}

let greeting = greetClosure("Swift")
print(greeting)  // 出力: Hello, Swift!

let mockAPIRequest: (Bool) -> (String) = { isSuccess in
    if isSuccess {
        return "Success: Data fetched!"
    } else {
        return "Error: Failed to fetch data."
    }
}

let mockRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void

let mockRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
    if request == "validRequest" {
        // リクエストが成功した場合の処理
        completion(.success("Success: Data received"))
    } else {
        // リクエストが失敗した場合の処理
        completion(.failure(NSError(domain: "Invalid request", code: 400, userInfo: nil)))
    }
}

func testMockRequest() {
    let expectation = XCTestExpectation(description: "Mock request should return success")

    mockRequest("validRequest") { result in
        switch result {
        case .success(let message):
            XCTAssertEqual(message, "Success: Data received")
            expectation.fulfill()
        case .failure(let error):
            XCTFail("Request failed with error: \(error)")
        }
    }

    wait(for: [expectation], timeout: 1.0)
}

mockRequest("invalidRequest") { result in
    switch result {
    case .success(_):
        XCTFail("Request should not succeed")
    case .failure(let error):
        XCTAssertNotNil(error)
    }
}

func testAPIRequestWithMock() {
    let mockAPIRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
        if request == "validRequest" {
            completion(.success("Mocked success response"))
        } else {
            completion(.failure(NSError(domain: "Invalid request", code: 400, userInfo: nil)))
        }
    }

    mockAPIRequest("validRequest") { result in
        switch result {
        case .success(let response):
            XCTAssertEqual(response, "Mocked success response")
        case .failure:
            XCTFail("Test failed: Request should not fail")
        }
    }
}

func testAsyncFunctionWithMock() {
    let expectation = XCTestExpectation(description: "Async mock function should return result")

    let mockAsyncFunction: (@escaping (String) -> Void) -> Void = { completion in
        // 非同期処理をシミュレート
        DispatchQueue.global().async {
            sleep(1) // 1秒待機してレスポンスを返す
            completion("Mocked async response")
        }
    }

    mockAsyncFunction { result in
        XCTAssertEqual(result, "Mocked async response")
        expectation.fulfill()
    }

    wait(for: [expectation], timeout: 2.0)
}

func testDifferentResponses() {
    let mockFunction: (String) -> String = { input in
        if input == "case1" {
            return "Response for case1"
        } else if input == "case2" {
            return "Response for case2"
        } else {
            return "Default response"
        }
    }

    XCTAssertEqual(mockFunction("case1"), "Response for case1")
    XCTAssertEqual(mockFunction("case2"), "Response for case2")
    XCTAssertEqual(mockFunction("unknown"), "Default response")
}

func performAPIRequest(url: String, completion: @escaping (Result<String, Error>) -> Void) {
    // 通常のAPIリクエスト処理（実際のサーバーと通信）
    // ...
}

let mockAPIRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { url, completion in
    if url == "https://api.example.com/valid-endpoint" {
        // 成功時のレスポンスをシミュレート
        completion(.success("Mocked success response"))
    } else {
        // エラー時のレスポンスをシミュレート
        let error = NSError(domain: "Invalid URL", code: 404, userInfo: nil)
        completion(.failure(error))
    }
}

func testAPIRequest() {
    let expectation = XCTestExpectation(description: "Mock API request should return success")

    mockAPIRequest("https://api.example.com/valid-endpoint") { result in
        switch result {
        case .success(let response):
            XCTAssertEqual(response, "Mocked success response")
            expectation.fulfill()
        case .failure(let error):
            XCTFail("Request failed with error: \(error)")
        }
    }

    wait(for: [expectation], timeout: 1.0)
}

func testAPIRequestFailure() {
    let expectation = XCTestExpectation(description: "Mock API request should return error")

    mockAPIRequest("https://api.example.com/invalid-endpoint") { result in
        switch result {
        case .success(_):
            XCTFail("Request should not succeed")
        case .failure(let error):
            XCTAssertEqual(error.localizedDescription, "The operation couldn’t be completed. (Invalid URL error 404.)")
            expectation.fulfill()
        }
    }

    wait(for: [expectation], timeout: 1.0)
}

let mockFunction: (String) -> String = { input in
    switch input {
    case "case1":
        return "Response for case1"
    case "case2":
        return "Response for case2"
    default:
        return "Default response"
    }
}

func testMockFunctionWithArguments() {
    let result = mockFunction("case1")
    XCTAssertEqual(result, "Response for case1")

    let result2 = mockFunction("unknownCase")
    XCTAssertEqual(result2, "Default response")
}

let mockAPIRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { url, completion in
    if url == "validRequest" {
        completion(.success("Success response"))
    } else {
        let error = NSError(domain: "Invalid request", code: 400, userInfo: nil)
        completion(.failure(error))
    }
}

func testMockAPIRequest() {
    mockAPIRequest("validRequest") { result in
        switch result {
        case .success(let response):
            XCTAssertEqual(response, "Success response")
        case .failure:
            XCTFail("Request should not fail")
        }
    }

    mockAPIRequest("invalidRequest") { result in
        switch result {
        case .success:
            XCTFail("Request should not succeed")
        case .failure(let error):
            XCTAssertEqual(error.domain, "Invalid request")
        }
    }
}

let mockAsyncRequest: (@escaping (String) -> Void) -> Void = { completion in
    DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) {
        completion("Async response")
    }
}

var counter = 0
let incrementCounter = {
    counter += 1
}

incrementCounter()
print(counter)  // 出力: 1

class SomeClass {
    var value = 0
    lazy var someClosure: () -> Void = {
        self.value = 10
    }
}

let instance = SomeClass()
instance.someClosure()

class SomeClass {
    var value = 0
    lazy var someClosure: () -> Void = { [weak self] in
        self?.value = 10
    }
}

let instance = SomeClass()
instance.someClosure()

class SomeClass {
    var value = 0
    lazy var someClosure: () -> Void = { [unowned self] in
        self.value = 10
    }
}

class NetworkManager {
    var onCompletion: (() -> Void)?

    func performRequest() {
        DispatchQueue.global().async { [weak self] in
            // ネットワークリクエストの処理
            sleep(1)
            print("Request completed")

            // 完了時にクロージャを呼び出し
            self?.onCompletion?()
        }
    }
}

let manager = NetworkManager()
manager.onCompletion = {
    print("Completion handler called")
}
manager.performRequest()

let mockAsyncRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
    DispatchQueue.global().asyncAfter(deadline: .now() + 1.0) {
        if request == "validRequest" {
            completion(.success("Mocked success response"))
        } else {
            let error = NSError(domain: "Invalid request", code: 400, userInfo: nil)
            completion(.failure(error))
        }
    }
}

func testAsyncMockRequest() {
    let expectation = XCTestExpectation(description: "Mock API request should return success")

    mockAsyncRequest("validRequest") { result in
        switch result {
        case .success(let response):
            XCTAssertEqual(response, "Mocked success response")
            expectation.fulfill() // 非同期処理が完了したら期待値を満たす
        case .failure:
            XCTFail("Request should not fail")
        }
    }

    wait(for: [expectation], timeout: 2.0) // 処理の完了を待つ
}

func testAsyncMockRequestFailure() {
    let expectation = XCTestExpectation(description: "Mock API request should return error")

    mockAsyncRequest("invalidRequest") { result in
        switch result {
        case .success:
            XCTFail("Request should not succeed")
        case .failure(let error):
            XCTAssertEqual(error.domain, "Invalid request")
            expectation.fulfill()
        }
    }

    wait(for: [expectation], timeout: 2.0)
}

let delayedMockRequest: (String, @escaping (String) -> Void) -> Void = { request, completion in
    DispatchQueue.global().asyncAfter(deadline: .now() + 2.0) {
        completion("Delayed response for \(request)")
    }
}

let mockAPIRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
    if request == "invalidRequest" {
        // エラーをシミュレート
        let error = NSError(domain: "MockErrorDomain", code: 404, userInfo: [NSLocalizedDescriptionKey: "Resource not found"])
        completion(.failure(error))
    } else {
        // 成功をシミュレート
        completion(.success("Success response"))
    }
}

func testMockAPIRequestError() {
    let expectation = XCTestExpectation(description: "Mock API request should return error")

    mockAPIRequest("invalidRequest") { result in
        switch result {
        case .success:
            XCTFail("Request should not succeed")
        case .failure(let error as NSError):
            XCTAssertEqual(error.domain, "MockErrorDomain")
            XCTAssertEqual(error.code, 404)
            XCTAssertEqual(error.localizedDescription, "Resource not found")
            expectation.fulfill() // エラーが正しくハンドリングされたら完了
        }
    }

    wait(for: [expectation], timeout: 2.0)
}

let mockAPIWithMultipleErrors: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
    switch request {
    case "timeout":
        let error = NSError(domain: "MockErrorDomain", code: -1001, userInfo: [NSLocalizedDescriptionKey: "Request timed out"])
        completion(.failure(error))
    case "notFound":
        let error = NSError(domain: "MockErrorDomain", code: 404, userInfo: [NSLocalizedDescriptionKey: "Resource not found"])
        completion(.failure(error))
    default:
        completion(.success("Mocked success response"))
    }
}

func testMultipleErrorHandling() {
    let timeoutExpectation = XCTestExpectation(description: "Timeout error should be handled")
    let notFoundExpectation = XCTestExpectation(description: "Not found error should be handled")

    mockAPIWithMultipleErrors("timeout") { result in
        switch result {
        case .success:
            XCTFail("Request should not succeed")
        case .failure(let error as NSError):
            XCTAssertEqual(error.code, -1001)
            XCTAssertEqual(error.localizedDescription, "Request timed out")
            timeoutExpectation.fulfill()
        }
    }

    mockAPIWithMultipleErrors("notFound") { result in
        switch result {
        case .success:
            XCTFail("Request should not succeed")
        case .failure(let error as NSError):
            XCTAssertEqual(error.code, 404)
            XCTAssertEqual(error.localizedDescription, "Resource not found")
            notFoundExpectation.fulfill()
        }
    }

    wait(for: [timeoutExpectation, notFoundExpectation], timeout: 2.0)
}

func testRetryLogic() {
    var retryCount = 0
    let maxRetries = 3

    let mockRetryRequest: (String, @escaping (Result<String, Error>) -> Void) -> Void = { request, completion in
        if retryCount < maxRetries {
            retryCount += 1
            let error = NSError(domain: "MockErrorDomain", code: -1009, userInfo: [NSLocalizedDescriptionKey: "Network unavailable"])
            completion(.failure(error))
        } else {
            completion(.success("Success after retries"))
        }
    }

    let expectation = XCTestExpectation(description: "Request should succeed after retries")

    mockRetryRequest("retryRequest") { result in
        switch result {
        case .success(let response):
            XCTAssertEqual(response, "Success after retries")
            expectation.fulfill()
        case .failure:
            XCTFail("Request should eventually succeed")
        }
    }

    wait(for: [expectation], timeout: 5.0)
}