Is the following impossible to test?

[nashysolutions]

I want to test establishToken() but I don't think this is possible.

public protocol FetchRequest: Hashable {
    var uuid: UUIDGenerator { get }
    var createdDate: Date { get }
    var now: Date { get }
    var expiryDate: Date? { get }
}

public extension FetchRequest {
    
    var expiryDate: Date? {
        return nil
    }
    
    var isExpired: Bool {
        guard let expiry = expiryDate else {
            return false
        }
        return now > expiry
    }
}

public struct FetchToken: FetchRequest {
    
    @Dependency(\.uuid)
    public var uuid
    
    public let createdDate = Date()
    
    @Dependency(\.date.now)
    public var now
    
    public var expiryDate: Date? {
        createdDate.addingTimeInterval(3)
    }
}

extension FetchToken {
    
    public static func ==(lhs: FetchToken, rhs: FetchToken) -> Bool {
        return lhs.uuid() == rhs.uuid()
    }
    
    public func hash(into hasher: inout Hasher) {
        hasher.combine(uuid())
    }
}

public protocol GatewayTokeniser: AnyObject {
    var token: FetchToken? { get set }
}

public extension GatewayTokeniser {
    
    func establishToken() -> FetchToken {
        switch token {
        case .none:
            let token = FetchToken()
            self.token = token
            return token
        case .some(let unwrapped):
            if unwrapped.isExpired {
                self.token = nil
                return establishToken()
            }
            return unwrapped
        }
    }
}

My failing attempt

final class Mock: GatewayTokeniser {
    var token: FetchToken?
}

func testEstablishTokenExpired() {
    
    // Given - an expired token
    
    let now = Date()
    let future = now.addingTimeInterval(4)
    
    let identifierA = UUID()
    let expiredToken = withDependencies {
        $0.uuid = UUIDGenerator { identifierA }
        $0.date.now = future
    } operation: {
        FetchToken()
    }
    
    // When - calling establishToken() on the gateway
    
    let identifierB = UUID()
    let establishedToken = withDependencies {
        $0.uuid = UUIDGenerator { identifierB }
        $0.date.now = now
    } operation: {
        let gateway = Mock()
        gateway.token = expiredToken
        return gateway.establishToken()
    }
    
    // Then - we expect a new token
    
    XCTAssertNotEqual(expiredToken.uuid(), establishedToken.uuid())
    XCTAssertFalse(establishedToken.isExpired)
}

[tgrapperon]

Hey @nashysolutions!
I feel that your spec is not quite right. I think you should snapshot the UUID in the FetchToken's init, otherwise, you'll generate a new UUIDs each time you compare them in live contexts. You should also probably use the Date dependency to set your createdDate date in FetchToken:

public struct FetchToken: FetchRequest {
    public let createdDate: Date
    public let uuid: UUID
    
    public var expiryDate: Date? {
        createdDate.addingTimeInterval(3)
    }
   
    init() {
        @Dependency(\.date) var date: DateGenerator
        @Dependency(\.uuid) var uuid: UUIDGenerator

        self.createdDate = date()
	    self.uuid = uuid()
    }
}

You may need to adjust your FetchRequest requirement though. I'm not sure this type should bear a .now property, nor a UUIDGenerator for example. You may also need to adjust your date overrides when testing: either create expiredToken now an test in the future, or create expiredToken in the past and test now.

[nashysolutions]

This is great. Didn't think to put @dependency in init like this.
Thank you.