Test real SMS verification in the iOS simulator

import Foundation
 
actor PhonekitFixture {
    enum Failure: Error {
        case invalidURL, invalidResponse, httpStatus(Int), invalidOptions, timeout, missingOtp
    }
    private struct Mark: Decodable { let cursor: String }
    private struct Receipt: Decodable {
        struct Message: Decodable { let otp: String? }
        let data: [Message]
        let cursor: String
    }
    private let session: URLSession
    private let apiKey: String
    private let numberURL: URL
 
    init(apiKey: String, numberRef: String, session: URLSession = .shared) throws {
        guard let base = URL(string: "https://www.phonekit.io/api/v1/numbers") else {
            throw Failure.invalidURL
        }
        self.session = session
        self.apiKey = apiKey
        self.numberURL = base.appendingPathComponent(numberRef)
    }
 
    func mark() async throws -> String {
        let (data, response) = try await request("cursor", timeout: 30)
        guard response.statusCode == 200 else {
            throw Failure.httpStatus(response.statusCode)
        }
        return try JSONDecoder().decode(Mark.self, from: data).cursor
    }
 
    func waitForOtp(
        after: String,
        timeout: TimeInterval,
        pollInterval: TimeInterval = 1
    ) async throws -> String {
        guard timeout.isFinite, timeout > 0,
              pollInterval.isFinite, pollInterval > 0 else {
            throw Failure.invalidOptions
        }
        let clock = ContinuousClock()
        let deadline = clock.now.advanced(by: .seconds(timeout))
        var cursor = after
        while clock.now < deadline {
            try Task.checkCancellation()
            let remaining = clock.now.duration(to: deadline).components
            let seconds = Double(remaining.seconds) + Double(remaining.attoseconds) / 1e18
            let (data, response) = try await request(
                "messages/after",
                query: [
                    URLQueryItem(name: "after", value: cursor),
                    URLQueryItem(name: "limit", value: "1")
                ],
                timeout: seconds
            )
            try Task.checkCancellation()
            guard clock.now < deadline else { throw Failure.timeout }
            guard response.statusCode == 200 else {
                throw Failure.httpStatus(response.statusCode)
            }
            let receipt = try JSONDecoder().decode(Receipt.self, from: data)
            cursor = receipt.cursor
            if let message = receipt.data.first {
                guard let code = message.otp, !code.isEmpty else {
                    throw Failure.missingOtp
                }
                return code
            }
            let nextRead = min(clock.now.advanced(by: .seconds(pollInterval)), deadline)
            try await clock.sleep(until: nextRead)
        }
        throw Failure.timeout
    }
 
    private func request(
        _ suffix: String,
        query: [URLQueryItem] = [],
        timeout: TimeInterval
    ) async throws -> (Data, HTTPURLResponse) {
        var components = URLComponents(
            url: numberURL.appendingPathComponent(suffix),
            resolvingAgainstBaseURL: false
        )
        components?.queryItems = query.isEmpty ? nil : query
        guard let url = components?.url else { throw Failure.invalidURL }
        var request = URLRequest(url: url)
        request.timeoutInterval = timeout
        request.setValue("Bearer " + apiKey, forHTTPHeaderField: "Authorization")
        let (data, response) = try await session.data(for: request)
        guard let http = response as? HTTPURLResponse else {
            throw Failure.invalidResponse
        }
        return (data, http)
    }
}

import XCTest
 
@MainActor
final class PhoneVerificationUITests: XCTestCase {
    func testSignInWithRealSMS() async throws {
        let environment = ProcessInfo.processInfo.environment
        guard let key = environment["PHONEKIT_API_KEY"], !key.isEmpty,
              let phone = environment["TEST_PHONE_NUMBER"], !phone.isEmpty else {
            XCTFail("Set PHONEKIT_API_KEY and TEST_PHONE_NUMBER for the test runner")
            return
        }
        let inbox = try PhonekitFixture(apiKey: key, numberRef: phone)
        let app = XCUIApplication()
        app.launch()
        let phoneField = app.textFields["phone-number"]
        XCTAssertTrue(phoneField.waitForExistence(timeout: 10))
        phoneField.tap()
        phoneField.typeText(phone)
 
        let after = try await inbox.mark()
        app.buttons["send-code"].tap()
        let code = try await inbox.waitForOtp(after: after, timeout: 120)
        let codeField = app.textFields["verification-code"]
        XCTAssertTrue(codeField.waitForExistence(timeout: 10))
        codeField.tap()
        codeField.typeText(code)
        app.buttons["verify-code"].tap()
 
        XCTAssertTrue(app.staticTexts["account-heading"].waitForExistence(timeout: 15))
    }
}