chore(test): Asserting interactions on MockFaceDetector and MockLivenessService

Author: jcjimenez

Tests/FaceLivenessTests/LivenessTests.swift

@@ -7,9 +7,12 @@ import Combine
 final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
     var videoChunker: VideoChunker!
     var viewModel: FaceLivenessDetectionViewModel!
+    var faceDetector: MockFaceDetector!
+    var livenessService: MockLivenessService!
 
     override func setUp() {
-        let faceDetector = MockFaceDetector()
+        faceDetector = MockFaceDetector()
+        livenessService = MockLivenessService()
         let videoChunker = VideoChunker(
             assetWriter: LivenessAVAssetWriter(),
             assetWriterDelegate: VideoChunker.AssetWriterDelegate(),
@@ -40,18 +43,32 @@ final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
     /// When: The viewModel is first initialized
     /// Then: The state is `.intitial`
     func testInitialState() {
-        viewModel.livenessService = MockLivenessService()
+        // This first call comes from the FaceLivenessDetectionViewModel's initializer
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [])
+
+        viewModel.livenessService = self.livenessService
         XCTAssertEqual(viewModel.livenessState.state, .initial)
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [])
     }
 
     /// Given:  A `FaceLivenessDetectionViewModel`
     /// When: The viewModel is processes the happy path events
     /// Then: The end state of this flow is `.faceMatched`
     func testHappyPathToMatchedFace() async throws {
-        viewModel.livenessService = MockLivenessService()
+        viewModel.livenessService = self.livenessService
 
         viewModel.livenessState.checkIsFacePrepared()
         XCTAssertEqual(viewModel.livenessState.state, .pendingFacePreparedConfirmation(.pendingCheck))
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [])
 
         viewModel.initializeLivenessStream()
         viewModel.process(newResult: .noFace)
@@ -76,5 +93,11 @@ final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
 
         viewModel.livenessState.faceMatched()
         XCTAssertEqual(viewModel.livenessState.state, .faceMatched)
+        XCTAssertEqual(faceDetector.interactions, [
+            "setResultHandler(detectionResultHandler:) (FaceLivenessDetectionViewModel)"
+        ])
+        XCTAssertEqual(livenessService.interactions, [
+            "initializeLivenessStream(withSessionID:userAgent:)"
+        ])
     }
 }

Tests/FaceLivenessTests/MockFaceDetectionResultHandler.swift

@@ -0,0 +1,18 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+@testable import FaceLiveness
+
+final class MockFaceDetectionResultHandler {
+    var intereactions: [String] = []
+}
+
+extension MockFaceDetectionResultHandler: FaceDetectionResultHandler {
+    func process(newResult: FaceLiveness.FaceDetectionResult) {
+        intereactions.append(#function)
+    }
+}

Tests/FaceLivenessTests/MockFaceDetector.swift

@@ -9,8 +9,19 @@ import AVFoundation
 @testable import FaceLiveness
 @_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
 
-class MockFaceDetector: FaceDetector {
-    func detectFaces(from buffer: CVPixelBuffer) {}
-    func setResultHandler(detectionResultHandler: FaceLiveness.FaceDetectionResultHandler) {}
-    init() {}
+final class MockFaceDetector {
+    var interactions: [String] = []
+    var detectionResultHandler: FaceDetectionResultHandler = MockFaceDetectionResultHandler()
+}
+
+extension MockFaceDetector: FaceDetector {
+
+    func detectFaces(from buffer: CVPixelBuffer) {
+        interactions.append(#function)
+    }
+
+    func setResultHandler(detectionResultHandler: FaceDetectionResultHandler) {
+        interactions.append("\(#function) (\(type(of: detectionResultHandler)))")
+        self.detectionResultHandler = detectionResultHandler
+    }
 }

Tests/FaceLivenessTests/MockLivenessService.swift

@@ -9,15 +9,23 @@ import Foundation
 @testable import FaceLiveness
 @_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
 
-class MockLivenessService: LivenessService {
+class MockLivenessService {
+
+    var interactions: [String] = []
+
     var onInitialClientEvent: (LivenessEvent<InitialClientEvent>, Date) -> Void = { _, _ in }
     var onFaceDetectionEvent: (LivenessEvent<FaceDetection>, Date) -> Void = { _, _ in }
     var onFinalClientEvent: (LivenessEvent<FinalClientEvent>, Date) -> Void = { _, _ in }
     var onFreshnessEvent: (LivenessEvent<FreshnessEvent>, Date) -> Void = { _, _ in }
     var onVideoEvent: (LivenessEvent<VideoEvent>, Date) -> Void = { _, _ in }
     var onInitializeLivenessStream: (String, String) -> Void = { _, _ in }
+}
+
+extension MockLivenessService: LivenessService {
 
     func send<T>(_ event: LivenessEvent<T>, eventDate: () -> Date) {
+        interactions.append(#function)
+
         switch event {
         case let initialClient as LivenessEvent<InitialClientEvent>:
             onInitialClientEvent(initialClient, eventDate())
@@ -36,15 +44,20 @@ class MockLivenessService: LivenessService {
     func initializeLivenessStream(
         withSessionID sessionID: String, userAgent: String
     ) throws {
+        interactions.append(#function)
         onInitializeLivenessStream(sessionID, userAgent)
     }
 
     func register(
         onComplete: @escaping (ServerDisconnection) -> Void
-    ) {}
+    ) {
+        interactions.append(#function)
+    }
 
     func register(
         listener: @escaping (FaceLivenessSession.SessionConfiguration) -> Void,
         on event: LivenessEventKind.Server
-    ) {}
+    ) {
+        interactions.append(#function)
+    }
 }