test: view model state transitions (#14)

Author: atierian

Tests/FaceLivenessTests/LivenessTests.swift

@@ -1,4 +1,111 @@
 import XCTest
+import Combine
 @testable import FaceLiveness
+@_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
 
-final class LivenessTests: XCTestCase {}
+@MainActor
+final class FaceLivenessDetectionViewModelTestCase: XCTestCase {
+    var videoChunker: VideoChunker!
+    var viewModel: FaceLivenessDetectionViewModel!
+
+    override func setUp() {
+        let faceDetector = MockFaceDetector()
+        let videoChunker = VideoChunker(
+            assetWriter: LivenessAVAssetWriter(),
+            assetWriterDelegate: VideoChunker.AssetWriterDelegate(),
+            assetWriterInput: LivenessAVAssetWriterInput()
+        )
+        let captureSession = LivenessCaptureSession(
+            captureDevice: .init(avCaptureDevice: nil),
+            outputDelegate: OutputSampleBufferCapturer(
+                faceDetector: faceDetector,
+                videoChunker: videoChunker
+            )
+        )
+
+        let viewModel = FaceLivenessDetectionViewModel(
+            faceDetector: faceDetector,
+            faceInOvalMatching: .init(instructor: .init()),
+            captureSession: captureSession,
+            videoChunker: videoChunker,
+            closeButtonAction: {},
+            sessionID: UUID().uuidString
+        )
+
+        self.videoChunker = videoChunker
+        self.viewModel = viewModel
+    }
+
+    /// Given:  A `FaceLivenessDetectionViewModel`
+    /// When: The viewModel is first initialized
+    /// Then: The state is `.intitial`
+    func testInitialState() {
+        viewModel.livenessService = MockLivenessService()
+        XCTAssertEqual(viewModel.livenessState.state, .initial)
+    }
+
+    /// 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.livenessState.checkIsFacePrepared()
+        XCTAssertEqual(viewModel.livenessState.state, .pendingFacePreparedConfirmation(.pendingCheck))
+
+        viewModel.initializeLivenessStream()
+        viewModel.process(newResult: .noFace)
+        XCTAssertEqual(videoChunker.state, .pending)
+
+        viewModel.sendInitialFaceDetectedEvent(
+            initialFace: .zero,
+            videoStartTime: Date().timestampMilliseconds
+        )
+        XCTAssertEqual(videoChunker.state, .writing)
+
+        let initialSegment = Data([0, 1])
+        var currentSegment = Data([25, 42])
+        XCTAssertFalse(viewModel.hasSentFirstVideo)
+        let chunk = viewModel.chunk(initial: initialSegment, current: currentSegment)
+        XCTAssertEqual(chunk, initialSegment + currentSegment)
+        XCTAssertTrue(viewModel.hasSentFirstVideo)
+
+        currentSegment = Data([42, 25])
+        let subsequentChunk = viewModel.chunk(initial: initialSegment, current: currentSegment)
+        XCTAssertEqual(subsequentChunk, currentSegment)
+
+        viewModel.livenessState.faceMatched()
+        XCTAssertEqual(viewModel.livenessState.state, .faceMatched)
+    }
+
+    /// Given:  A `FaceLivenessDetectionViewModel`
+    /// When: The viewModel state `.countingDown` and receives
+    /// an event from the face detector with `.noFace`
+    /// Then: The flow bails with an `encounteredUnrecoverableError(.invalidFaceMovementDuringCountdown)`
+    var stateChangeCancellable: Set<AnyCancellable>!
+    func testInvalidFaceMovementDuringCountdown() {
+        stateChangeCancellable = Set<AnyCancellable>()
+        viewModel.livenessService = MockLivenessService()
+        viewModel.livenessState.checkIsFacePrepared()
+        viewModel.livenessState.startCountdown()
+        XCTAssertEqual(viewModel.livenessState.state, .countingDown)
+
+        let stateChangeExpectation = expectation(
+            description: "waiting on state change after invalid face movement"
+        )
+
+        viewModel.$livenessState
+            .drop(while: { $0.state == .countingDown })
+            .sink { stateMachine in
+                XCTAssertEqual(
+                    stateMachine.state,
+                    .encounteredUnrecoverableError(.invalidFaceMovementDuringCountdown)
+                )
+                stateChangeExpectation.fulfill()
+            }
+        .store(in: &stateChangeCancellable)
+
+        viewModel.process(newResult: .noFace)
+        wait(for: [stateChangeExpectation], timeout: 0.1)
+    }
+}

Tests/FaceLivenessTests/MockFaceDetector.swift

@@ -0,0 +1,16 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import AVFoundation
+@testable import FaceLiveness
+@_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
+
+class MockFaceDetector: FaceDetector {
+    func detectFaces(from buffer: CVPixelBuffer) {}
+    func setResultHandler(detectionResultHandler: FaceLiveness.FaceDetectionResultHandler) {}
+    init() {}
+}

Tests/FaceLivenessTests/MockLivenessService.swift

@@ -0,0 +1,50 @@
+//
+// Copyright Amazon.com Inc. or its affiliates.
+// All Rights Reserved.
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+
+import Foundation
+@testable import FaceLiveness
+@_spi(PredictionsFaceLiveness) import AWSPredictionsPlugin
+
+class MockLivenessService: LivenessService {
+    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 }
+
+    func send<T>(_ event: LivenessEvent<T>, eventDate: () -> Date) {
+        switch event {
+        case let initialClient as LivenessEvent<InitialClientEvent>:
+            onInitialClientEvent(initialClient, eventDate())
+        case let faceDetection as LivenessEvent<FaceDetection>:
+            onFaceDetectionEvent(faceDetection, eventDate())
+        case let finalClient as LivenessEvent<FinalClientEvent>:
+            onFinalClientEvent(finalClient, eventDate())
+        case let freshness as LivenessEvent<FreshnessEvent>:
+            onFreshnessEvent(freshness, eventDate())
+        case let video as LivenessEvent<VideoEvent>:
+            onVideoEvent(video, eventDate())
+        default: break
+        }
+    }
+
+    func initializeLivenessStream(
+        withSessionID sessionID: String, userAgent: String
+    ) throws {
+        onInitializeLivenessStream(sessionID, userAgent)
+    }
+
+    func register(
+        onComplete: @escaping (ServerDisconnection) -> Void
+    ) {}
+
+    func register(
+        listener: @escaping (FaceLivenessSession.SessionConfiguration) -> Void,
+        on event: LivenessEventKind.Server
+    ) {}
+}