Commit ⋅ aws-amplify/amplify-ios

@@ -12,6 +12,8 @@

Loading


class MockTranscribeBehavior: AWSTranscribeStreamingBehavior {

    var delegate: AWSTranscribeStreamingClientDelegate?
    var callbackQueue: DispatchQueue?
    var transcriptionResult: AWSTranscribeStreamingTranscriptResultStream?
    var error: Error?


@@ -26,14 +28,16 @@

Loading


    public func setResult(result: AWSTranscribeStreamingTranscriptResultStream?) {
        transcriptionResult = result
        error = nil
    }

    func startTranscriptionWSS(request: AWSTranscribeStreamingStartStreamTranscriptionRequest) {

        delegate?.didReceiveEvent(transcriptionResult, decodingError: error)
    }

    func setDelegate(delegate: AWSTranscribeStreamingClientDelegate, callbackQueue: DispatchQueue) {

        self.delegate = delegate
        self.callbackQueue = callbackQueue
    }

    func send(data: Data, headers: [String: String]) {

@@ -78,6 +78,8 @@

Loading

    ///
    func testIdentifyLabelsService() {
        setUpAmplify()

        let resultReceived = expectation(description: "Transcription result should be returned")
        let mockResponse: AWSRekognitionDetectLabelsResponse = AWSRekognitionDetectLabelsResponse()
        mockResponse.labels = [AWSRekognitionLabel]()


@@ -94,10 +96,13 @@

Loading

                let labelResult = result as? IdentifyLabelsResult
                let labels = IdentifyLabelsResultTransformers.processLabels(mockResponse.labels!)
                XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated

@@ -110,6 +115,8 @@

Loading

    ///
    func testIdentifyLabelsServiceWithError() {
        setUpAmplify()

        let errorReceived = expectation(description: "Error should be returned")
        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])

@@ -122,8 +129,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated

@@ -136,8 +146,9 @@

Loading

    ///
    func testIdentifyLabelsServiceWithNilResponse() {
        setUpAmplify()

        mockRekognition.setLabelsResponse(result: nil)

        let errorReceived = expectation(description: "Error should be returned")
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
            XCTFail("Unable to find image")

@@ -150,8 +161,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successful rekognition call to identify moderation labels

@@ -164,6 +178,8 @@

Loading

    ///
    func testIdentifyModerationLabelsService() {
        setUpAmplify()

        let resultReceived = expectation(description: "Transcription result should be returned")
        let mockResponse: AWSRekognitionDetectModerationLabelsResponse = AWSRekognitionDetectModerationLabelsResponse()
        mockResponse.moderationLabels = [AWSRekognitionModerationLabel]()


@@ -182,10 +198,13 @@

Loading

                XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
                XCTAssertNotNil(labelResult?.unsafeContent,
                                "unsafe content should have a boolean in it since we called moderation labels")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is prograted correctly when making a rekognition call to identify moderation labels

@@ -198,6 +217,8 @@

Loading

    ///
    func testIdentifyModerationLabelsServiceWithError() {
        setUpAmplify()

        let errorReceived = expectation(description: "Error should be returned")
        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])

@@ -207,11 +228,14 @@

Loading

        predictionsService.detectLabels(image: url, type: .moderation) { event in
            switch event {
            case .completed(let result):
                  XCTFail("Should not produce result: \(result)")
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successful rekognition call to identify moderation labels but receive a nil response

@@ -224,8 +248,9 @@

Loading

    ///
    func testIdentifyModerationLabelsServiceWithNilResponse() {
        setUpAmplify()

        mockRekognition.setModerationLabelsResponse(result: nil)

        let errorReceived = expectation(description: "Error should be returned")
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
            XCTFail("Unable to find image")

@@ -235,11 +260,14 @@

Loading

        predictionsService.detectLabels(image: url, type: .moderation) { event in
            switch event {
            case .completed(let result):
                  XCTFail("Should not produce result: \(result)")
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successful rekognition call to identify all labels

@@ -252,6 +280,8 @@

Loading

    ///
    func testIdentifyAllLabelsService() {
        setUpAmplify()

        let resultReceived = expectation(description: "Transcription result should be returned")
        let mockLabelsResponse: AWSRekognitionDetectLabelsResponse = AWSRekognitionDetectLabelsResponse()
        mockLabelsResponse.labels = [AWSRekognitionLabel]()


@@ -274,10 +304,13 @@

Loading

                XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
                XCTAssertNotNil(labelResult?.unsafeContent,
                                "unsafe content should have a boolean in it since we called all labels")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is prograted correctly when making a rekognition call to identify all labels

@@ -291,20 +324,27 @@

Loading

    func testIdentifyAllLabelsServiceWithNilResponse() {
        setUpAmplify()
        mockRekognition.setAllLabelsResponse(labelsResult: nil, moderationResult: nil)

        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }

        let errorReceived = expectation(description: "Error should be returned")
        errorReceived.expectedFulfillmentCount = 2

        predictionsService.detectLabels(image: url, type: .all) { event in
            switch event {
            case .completed(let result):
                  XCTFail("Should not produce result: \(result)")
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is prograted correctly when making a rekognition call to identify all labels

@@ -317,20 +357,25 @@

Loading

    ///
    func testIdentifyAllLabelsServiceWithError() {
        setUpAmplify()

        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])
        mockRekognition.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectLabels(image: url, type: .all) { event in
            switch event {
            case .completed(let result):
                  XCTFail("Should not produce result: \(result)")
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successfull rekognition call to identify entities

@@ -343,6 +388,7 @@

Loading

    ///
    func testIdentifyEntitiesService() {
        setUpAmplify()

        let mockResponse: AWSRekognitionDetectFacesResponse = AWSRekognitionDetectFacesResponse()
        mockResponse.faceDetails = [AWSRekognitionFaceDetail]()


@@ -353,16 +399,21 @@

Loading

            return
        }

        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {
            case .completed(let result):
                let entitiesResult = result as? IdentifyEntitiesResult
                let newFaces = IdentifyEntitiesResultTransformers.processFaces(mockResponse.faceDetails!)
                XCTAssertEqual(entitiesResult?.entities.count, newFaces.count, "Faces count number should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for detecting entities

@@ -375,11 +426,13 @@

Loading

    ///
    func testIdentifyEntitiesServiceWithError() {
        setUpAmplify()

        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])
        mockRekognition.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {

@@ -387,8 +440,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for detecting entities when a nil response is received

@@ -402,11 +458,13 @@

Loading

    func testIdentifyEntitiesServiceWithNilResponse() {
        setUpAmplify()
        mockRekognition.setFacesResponse(result: nil)

        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageEntities", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {

@@ -414,8 +472,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successfull rekognition call to identify entities from a collection

@@ -428,6 +489,7 @@

Loading

    ///
    func testIdentifyEntityMatchesService() {
        setUpAmplify(withCollection: true)

        let mockResponse: AWSRekognitionSearchFacesByImageResponse = AWSRekognitionSearchFacesByImageResponse()
        mockResponse.faceMatches = [AWSRekognitionFaceMatch]()


@@ -437,6 +499,7 @@

Loading

            XCTFail("Unable to find image")
            return
        }
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {

@@ -444,10 +507,13 @@

Loading

                let entitiesResult = result as? IdentifyEntityMatchesResult
                let newFaces = IdentifyEntitiesResultTransformers.processCollectionFaces(mockResponse.faceMatches!)
                XCTAssertEqual(entitiesResult?.entities.count, newFaces.count, "Faces count number should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for entity matches

@@ -460,11 +526,13 @@

Loading

    ///
    func testIdentifyEntityMatchesServiceWithError() {
        setUpAmplify(withCollection: true)

        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])
        mockRekognition.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {

@@ -472,8 +540,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for entity matches when request is nil

@@ -487,11 +558,13 @@

Loading

    func testIdentifyEntityMatchesServiceWithNilResponse() {
        setUpAmplify(withCollection: true)
        mockRekognition.setFacesFromCollection(result: nil)

        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageEntities", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectEntities(image: url) { event in
            switch event {

@@ -499,8 +572,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successfull rekognition call to identify plain text

@@ -513,6 +589,7 @@

Loading

    ///
    func testIdentifyPlainTextService() {
        setUpAmplify()

        let mockResponse: AWSRekognitionDetectTextResponse = AWSRekognitionDetectTextResponse()
        mockResponse.textDetections = [AWSRekognitionTextDetection]()


@@ -522,6 +599,7 @@

Loading

            XCTFail("Unable to find image")
            return
        }
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectText(image: url, format: .plain) { event in
            switch event {

@@ -530,10 +608,13 @@

Loading

                let newText = IdentifyTextResultTransformers.processText(mockResponse.textDetections!)
                XCTAssertEqual(textResult?.identifiedLines?.count,
                               newText.identifiedLines?.count, "Text line count number should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches

@@ -546,11 +627,13 @@

Loading

    ///
    func testIdentifyPlainTextServiceWithError() {
        setUpAmplify()

        let mockError = NSError(domain: AWSRekognitionErrorDomain,
                                code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
                                userInfo: [:])
        mockRekognition.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .plain) { event in
            switch event {

@@ -558,8 +641,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches and receive a nil response

@@ -579,6 +665,7 @@

Loading

            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .plain) { event in
            switch event {

@@ -586,7 +673,10 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }
}

@@ -17,18 +17,18 @@

Loading

    var error: Error?

    func analyzeDocument(request: AWSTextractAnalyzeDocumentRequest) -> AWSTask<AWSTextractAnalyzeDocumentResponse> {
        if let finalResult = analyzeDocument {
            return AWSTask(result: finalResult)
        guard let finalError = error else {
            return AWSTask(result: analyzeDocument)
        }
        return AWSTask(error: error!)
        return AWSTask(error: finalError)
    }

    func detectDocumentText(request: AWSTextractDetectDocumentTextRequest)
        -> AWSTask<AWSTextractDetectDocumentTextResponse> {
            if let finalResult = detectDocumentText {
                return AWSTask(result: finalResult)
            }
            return AWSTask(error: error!)
    -> AWSTask<AWSTextractDetectDocumentTextResponse> {
        guard let finalError = error else {
            return AWSTask(result: detectDocumentText)
        }
        return AWSTask(error: finalError)
    }

    func getTextract() -> AWSTextract {

@@ -12,7 +12,7 @@

Loading

import Foundation
@testable import AWSPredictionsPlugin

class PredictionsServiceTextractTests: XCTest {
class PredictionsServiceTextractTests: XCTestCase {
    var predictionsService: AWSPredictionsService!
    let mockTextract = MockTextractBehavior()


@@ -59,21 +59,25 @@

Loading

        mockTextract.setAnalyzeDocument(result: mockResponse)
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
             XCTFail("Unable to find image")
             return
            XCTFail("Unable to find image")
            return
        }
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectText(image: url, format: .table) { event in
            switch event {
            case .completed(let result):
                let textResult = result as? IdentifyTextResult
                let textResult = result as? IdentifyDocumentTextResult
                let text = IdentifyTextResultTransformers.processText(mockResponse.blocks!)
                XCTAssertEqual(textResult?.identifiedLines?.count,
                XCTAssertEqual(textResult?.identifiedLines.count,
                               text.identifiedLines.count, "Line count should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches

@@ -90,15 +94,19 @@

Loading

                                userInfo: [:])
        mockTextract.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

            predictionsService.detectText(image: url, format: .table) { event in
        predictionsService.detectText(image: url, format: .table) { event in
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches with nil response

@@ -110,21 +118,25 @@

Loading

    ///    - I should get back a service error
    ///
    func testIdentifyTablesServiceWithNilResponse() {

        mockTextract.setAnalyzeDocument(result: nil)
            let testBundle = Bundle(for: type(of: self))
            guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
                XCTFail("Unable to find image")
                return
            }
            predictionsService.detectText(image: url, format: .table) { event in
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .table) { event in
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successfull textract call to identify forms

@@ -142,21 +154,25 @@

Loading

        mockTextract.setAnalyzeDocument(result: mockResponse)
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
             XCTFail("Unable to find image")
             return
            XCTFail("Unable to find image")
            return
        }
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectText(image: url, format: .form) { event in
            switch event {
            case .completed(let result):
                let textResult = result as? IdentifyTextResult
                let textResult = result as? IdentifyDocumentTextResult
                let text = IdentifyTextResultTransformers.processText(mockResponse.blocks!)
                XCTAssertEqual(textResult?.identifiedLines?.count,
                XCTAssertEqual(textResult?.identifiedLines.count,
                               text.identifiedLines.count, "Line count should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for document text matches

@@ -173,6 +189,7 @@

Loading

                                userInfo: [:])
        mockTextract.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .form) { event in
            switch event {

@@ -180,8 +197,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches with nil response

@@ -193,21 +213,25 @@

Loading

    ///    - I should get back a service error because response is nil
    ///
    func testIdentifyFormsServiceWithNilResponse() {

        mockTextract.setAnalyzeDocument(result: nil)
            let testBundle = Bundle(for: type(of: self))
            guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
                XCTFail("Unable to find image")
                return
            }
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .form) { event in
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we can make a successfull textract call to identify forms and tables

@@ -225,21 +249,25 @@

Loading

        mockTextract.setAnalyzeDocument(result: mockResponse)
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
             XCTFail("Unable to find image")
             return
            XCTFail("Unable to find image")
            return
        }
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.detectText(image: url, format: .all) { event in
            switch event {
            case .completed(let result):
                let textResult = result as? IdentifyTextResult
                let textResult = result as? IdentifyDocumentTextResult
                let text = IdentifyTextResultTransformers.processText(mockResponse.blocks!)
                XCTAssertEqual(textResult?.identifiedLines?.count,
                XCTAssertEqual(textResult?.identifiedLines.count,
                               text.identifiedLines.count, "Line count should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for .all document text matches

@@ -256,6 +284,7 @@

Loading

                                userInfo: [:])
        mockTextract.setError(error: mockError)
        let url = URL(fileURLWithPath: "")
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .all) { event in
            switch event {

@@ -263,8 +292,11 @@

Loading

                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated for text matches with nil response

@@ -276,20 +308,24 @@

Loading

    ///    - I should get back a service error because response is nil
    ///
    func testIdentifyAllTextServiceWithNilResponse() {

        mockTextract.setAnalyzeDocument(result: nil)
            let testBundle = Bundle(for: type(of: self))
            guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
                XCTFail("Unable to find image")
                return
            }
        let testBundle = Bundle(for: type(of: self))
        guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
            XCTFail("Unable to find image")
            return
        }
        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.detectText(image: url, format: .all) { event in
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }
}

@@ -59,16 +59,22 @@

Loading

        english.languageCode = "en"
        english.score = 0.5
        let mockDominantLanguage = mockDominantLanguageResult([english])

        let resultReceived = expectation(description: "Transcription result should be returned")

        mockComprehend.setResult(languageResponse: mockDominantLanguage)
        predictionsService.comprehend(text: inputForTest) { event in
            switch event {
            case .completed(let result):
                XCTAssertNotNil(result, "Result should be non-nil")
                XCTAssertEqual(result.language?.languageCode, .english, "Dominant language should match")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we get correct dominant language for multiple languages

@@ -89,17 +95,23 @@

Loading

        let italian = AWSComprehendDominantLanguage()!
        italian.languageCode = "it"
        italian.score = 0.6

        let mockDominantLanguage = mockDominantLanguageResult([english, spanish, italian])
        let resultReceived = expectation(description: "Transcription result should be returned")

        mockComprehend.setResult(languageResponse: mockDominantLanguage)
        predictionsService.comprehend(text: inputForTest) { event in
            switch event {
            case .completed(let result):
                XCTAssertNotNil(result, "Result should be non-nil")
                XCTAssertEqual(result.language?.languageCode, .italian, "Dominant language should match")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether empty result from service gives us error

@@ -112,6 +124,8 @@

Loading

    ///
    func testWithEmptyLanguageResult() {
        let mockDominantLanguage = mockDominantLanguageResult()
        let errorReceived = expectation(description: "Error should be returned")

        mockComprehend.setResult(languageResponse: mockDominantLanguage)
        predictionsService.comprehend(text: inputForTest) { event in
            switch event {

@@ -119,8 +133,11 @@

Loading

                XCTFail("Should not produce result if the service cannot find the language. \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should return an error if language is nil. \(error)")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether returninng all nil from service gives us an error

@@ -132,6 +149,8 @@

Loading

    ///    - I should get an error
    ///
    func testAllNilResult() {
        let errorReceived = expectation(description: "Error should be returned")

        mockComprehend.setResult()
        predictionsService.comprehend(text: inputForTest) { event in
            switch event {

@@ -139,8 +158,11 @@

Loading

                XCTFail("Should not produce result if the service cannot find the language. \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should return an error if language is nil. \(error)")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether we get an error if service return error for language detection

@@ -155,6 +177,8 @@

Loading

        let mockError = NSError(domain: AWSComprehendErrorDomain,
                                code: AWSComprehendErrorType.internalServer.rawValue,
                                userInfo: [:])
        let errorReceived = expectation(description: "Error should be returned")

        mockComprehend.setError(error: mockError)
        predictionsService.comprehend(text: inputForTest) { event in
            switch event {

@@ -162,8 +186,11 @@

Loading

                XCTFail("Should not produce result if the service cannot find the language. \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should return an error if server returned an error. \(error)")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test a complete response

@@ -210,7 +237,9 @@

Loading

        keyPhrase.endOffset = 3
        keyPhrase.score = 0.8
        keyPhrase.text = "some text"

        let mockKeyPhrases = mockKeyPhrasesResult([keyPhrase])
        let resultReceived = expectation(description: "Transcription result should be returned")

        mockComprehend.setResult(sentimentResponse: mockSentiment,
                                 entitiesResponse: mockEntities,

@@ -222,10 +251,13 @@

Loading

            case .completed(let result):
                XCTAssertNotNil(result, "Result should be non-nil")
                XCTAssertEqual(result.language?.languageCode, .spanish, "Dominant language should match")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    // MARK: - Helper methods

@@ -36,11 +36,13 @@

Loading

                                                       awsTextract: MockTextractBehavior(),
                                                       awsComprehend: MockComprehendBehavior(),
                                                       awsPolly: MockPollyBehavior(),
                                                       awsTranscribeStreaming: MockTranscribeBehavior(),
                                                       awsTranscribeStreaming: mockTranscribe,
                                                       nativeWebSocketProvider: nativeWebSocketProvider,
                                                       transcribeClientDelegate: clientDelegate,
                                                       configuration: mockConfiguration)

            mockTranscribe.setDelegate(delegate: clientDelegate, callbackQueue: dispatchQueue)

            let testBundle = Bundle(for: type(of: self))
            guard let url = testBundle.url(forResource: "audio", withExtension: "wav") else {
                return

@@ -59,9 +61,11 @@

Loading

        let resultStream = AWSTranscribeStreamingResult()!
        let alternative = AWSTranscribeStreamingAlternative()!
        alternative.transcript = str
        resultStream.isPartial = false
        resultStream.alternatives = [alternative]
        results.results = [resultStream]
        transcriptEvent.transcript = results
        mockResponse.transcriptEvent = transcriptEvent
        return mockResponse
    }


@@ -74,17 +78,23 @@

Loading

    ///    - I should get back a result
    ///
    func testTranscribeService() {
         let transcription = "This is a test"
        let mockResponse = createMockTranscribeResponse()
        mockTranscribe.setResult(result: mockResponse)
        let expectedTranscription = "This is a test"
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.transcribe(speechToText: audioFile, language: .usEnglish) { event in
            switch event {
            case .completed(let result):
                XCTAssertEqual(result.transcription, transcription, "transcribed text should be the same")
                XCTAssertEqual(result.transcription, expectedTranscription, "transcribed text should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }

        }

        waitForExpectations(timeout: 1)

    }

    /// Test whether error is correctly propogated

@@ -101,15 +111,19 @@

Loading

                                userInfo: [:])
        mockTranscribe.setError(error: mockError)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.transcribe(speechToText: audioFile, language: .usEnglish) { event in
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }

        }

        waitForExpectations(timeout: 1)
    }

    /// Test if language from configuration is picked up

@@ -122,16 +136,16 @@

Loading

    ///
    func testLanguageFromConfiguration() {
        let mockConfigurationJSON = """
        {
            "defaultRegion": "us-east-1",
            "convert": {
                "transcription": {
                    "region": "us-east-1",
                    "language": "en-US"
            {
                "defaultRegion": "us-east-1",
                "convert": {
                    "transcription": {
                        "region": "us-east-1",
                        "language": "en-US"
                    }
                }
            }
        }
        """.data(using: .utf8)!
            """.data(using: .utf8)!
        do {
            let clientDelegate = NativeWSTranscribeStreamingClientDelegate()
            let dispatchQueue = DispatchQueue(label: "TranscribeStreamingTests")

@@ -149,21 +163,28 @@

Loading

                                                       nativeWebSocketProvider: nativeWebSocketProvider,
                                                       transcribeClientDelegate: clientDelegate,
                                                       configuration: mockConfiguration)

            mockTranscribe.setDelegate(delegate: clientDelegate, callbackQueue: dispatchQueue)
        } catch {
            XCTFail("Initialization of the service failed. \(error)")
        }

        let mockResponse = createMockTranscribeResponse()
        mockTranscribe.setResult(result: mockResponse)
        let expectedTranscription = "This is a test"
        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.transcribe(speechToText: audioFile, language: nil) {event in
            switch event {
            case .completed(let result):
                XCTAssertEqual(result.transcription, "This is a test", "Transcribed text should be the same")
                XCTAssertEqual(result.transcription, expectedTranscription, "Transcribed text should be the same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the service returns nil, we get an error back

@@ -176,13 +197,19 @@

Loading

    ///
    func testNilResult() {
        mockTranscribe.setResult(result: nil)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.transcribe(speechToText: audioFile, language: nil) {event in
            switch event {
            case .completed(let result):
                 XCTFail("Should not produce result: \(result)")
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                 XCTAssertNotNil(error, "Should produce an error")
             }
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }
}

@@ -56,18 +56,23 @@

Loading

        mockResponse.translatedText = "translated text here"
        mockTranslate.setResult(result: mockResponse)

        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.translateText(text: "Hello there",
                                         language: .english,
                                         targetLanguage: .italian) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTAssertEqual(result.text,
                                                               mockResponse.translatedText,
                                                               "Translated text should be same")
                                            case .failed(let error):
                                                XCTFail("Should not produce error: \(error)")
                                            }
            switch event {
            case .completed(let result):
                XCTAssertEqual(result.text,
                               mockResponse.translatedText,
                               "Translated text should be same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test whether error is correctly propogated

@@ -79,22 +84,26 @@

Loading

    ///    - I should get back a service error
    ///
    func testTranslateServiceWithError() {

        let mockError = NSError(domain: AWSTranslateErrorDomain,
                                code: AWSTranslateErrorType.invalidRequest.rawValue,
                                userInfo: [:])
        mockTranslate.setError(error: mockError)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.translateText(text: "",
                                         language: .english,
                                         targetLanguage: .italian) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTFail("Should not produce result: \(result)")
                                            case .failed(let error):
                                                XCTAssertNotNil(error, "Should produce an error")
                                            }
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if language from configuration is picked up

@@ -144,18 +153,23 @@

Loading

        mockResponse.translatedText = "translated text here"
        mockTranslate.setResult(result: mockResponse)

        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.translateText(text: "Hello there",
                              language: nil,
                              targetLanguage: nil) { event in
                                switch event {
                                case .completed(let result):
                                    XCTAssertEqual(result.text,
                                                   mockResponse.translatedText,
                                                   "Translated text should be same")
                                case .failed(let error):
                                    XCTFail("Should not produce error: \(error)")
                                }
                                         language: nil,
                                         targetLanguage: nil) { event in
            switch event {
            case .completed(let result):
                XCTAssertEqual(result.text,
                               mockResponse.translatedText,
                               "Translated text should be same")
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the source language is nil error is thrown

@@ -171,16 +185,21 @@

Loading

        mockResponse.translatedText = "translated text here"
        mockTranslate.setResult(result: mockResponse)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.translateText(text: "",
                                         language: nil,
                                         targetLanguage: .italian) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTFail("Should not produce result: \(result)")
                                            case .failed(let error):
                                                XCTAssertNotNil(error, "Should produce an error")
                                            }
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the target is nil and configuration is not set

@@ -196,16 +215,21 @@

Loading

        mockResponse.translatedText = "translated text here"
        mockTranslate.setResult(result: mockResponse)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.translateText(text: "",
                                         language: .english,
                                         targetLanguage: nil) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTFail("Should not produce result: \(result)")
                                            case .failed(let error):
                                                XCTAssertNotNil(error, "Should produce an error")
                                            }
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the service returns nil, we get an error back

@@ -218,16 +242,22 @@

Loading

    ///
    func testNilResult() {
        mockTranslate.setResult(result: nil)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.translateText(text: "",
                                         language: .english,
                                         targetLanguage: .spanish) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTFail("Should not produce result: \(result)")
                                            case .failed(let error):
                                                XCTAssertNotNil(error, "Should produce an error")
                                            }
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the service returns nil for translated text, we get an error back

@@ -241,16 +271,22 @@

Loading

    func testNilTranslatedTextResult() {
        let mockResponse = AWSTranslateTranslateTextResponse()!
        mockTranslate.setResult(result: mockResponse)

        let errorReceived = expectation(description: "Error should be returned")

        predictionsService.translateText(text: "",
                                         language: .english,
                                         targetLanguage: .spanish) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTFail("Should not produce result: \(result)")
                                            case .failed(let error):
                                                XCTAssertNotNil(error, "Should produce an error")
                                            }
            switch event {
            case .completed(let result):
                XCTFail("Should not produce result: \(result)")
            case .failed(let error):
                XCTAssertNotNil(error, "Should produce an error")
                errorReceived.fulfill()
            }
        }

        waitForExpectations(timeout: 1)
    }

    /// Test if the target language is set

@@ -266,18 +302,23 @@

Loading

        mockResponse.translatedText = "translated text here"
        mockTranslate.setResult(result: mockResponse)

        let resultReceived = expectation(description: "Transcription result should be returned")

        predictionsService.translateText(text: "Hello there",
                                         language: .english,
                                         targetLanguage: .malayalam) { event in
                                            switch event {
                                            case .completed(let result):
                                                XCTAssertEqual(result.text,
                                                               mockResponse.translatedText,
                                                               "Translated text should be same")
                                                 XCTAssertEqual(result.targetLanguage, .malayalam)
                                            case .failed(let error):
                                                XCTFail("Should not produce error: \(error)")
                                            }
            switch event {
            case .completed(let result):
                XCTAssertEqual(result.text,
                               mockResponse.translatedText,
                               "Translated text should be same")
                XCTAssertEqual(result.targetLanguage, .malayalam)
                resultReceived.fulfill()
            case .failed(let error):
                XCTFail("Should not produce error: \(error)")
            }
        }

        waitForExpectations(timeout: 1)
    }
}

182	198		XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
183	199		XCTAssertNotNil(labelResult?.unsafeContent,
184	200		"unsafe content should have a boolean in it since we called moderation labels")
	201	+	resultReceived.fulfill()
185	202		case .failed(let error):
186	203		XCTFail("Should not produce error: \(error)")
187	204		}
188	205		}
	206	+
	207	+	waitForExpectations(timeout: 1)
189	208		}
190	209
191	210		/// Test whether error is prograted correctly when making a rekognition call to identify moderation labels

274	304		XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
275	305		XCTAssertNotNil(labelResult?.unsafeContent,
276	306		"unsafe content should have a boolean in it since we called all labels")
	307	+	resultReceived.fulfill()
277	308		case .failed(let error):
278	309		XCTFail("Should not produce error: \(error)")
279	310		}
280	311		}
	312	+
	313	+	waitForExpectations(timeout: 1)
281	314		}
282	315
283	316		/// Test whether error is prograted correctly when making a rekognition call to identify all labels

291	324		func testIdentifyAllLabelsServiceWithNilResponse() {
292	325		setUpAmplify()
293	326		mockRekognition.setAllLabelsResponse(labelsResult: nil, moderationResult: nil)
	327	+
294	328		let testBundle = Bundle(for: type(of: self))
295	329		guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
296	330		XCTFail("Unable to find image")
297	331		return
298	332		}
299	333
	334	+	let errorReceived = expectation(description: "Error should be returned")
	335	+	errorReceived.expectedFulfillmentCount = 2
	336	+
300	337		predictionsService.detectLabels(image: url, type: .all) { event in
301	338		switch event {
302	339		case .completed(let result):
303		-	XCTFail("Should not produce result: \(result)")
	340	+	XCTFail("Should not produce result: \(result)")
304	341		case .failed(let error):
305	342		XCTAssertNotNil(error, "Should produce an error")
	343	+	errorReceived.fulfill()
306	344		}
307	345		}
	346	+
	347	+	waitForExpectations(timeout: 1)
308	348		}
309	349
310	350		/// Test whether error is prograted correctly when making a rekognition call to identify all labels

317	357		///
318	358		func testIdentifyAllLabelsServiceWithError() {
319	359		setUpAmplify()
	360	+
320	361		let mockError = NSError(domain: AWSRekognitionErrorDomain,
321	362		code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
322	363		userInfo: [:])
323	364		mockRekognition.setError(error: mockError)
324	365		let url = URL(fileURLWithPath: "")
	366	+	let errorReceived = expectation(description: "Error should be returned")
325	367
326	368		predictionsService.detectLabels(image: url, type: .all) { event in
327	369		switch event {
328	370		case .completed(let result):
329		-	XCTFail("Should not produce result: \(result)")
	371	+	XCTFail("Should not produce result: \(result)")
330	372		case .failed(let error):
331	373		XCTAssertNotNil(error, "Should produce an error")
	374	+	errorReceived.fulfill()
332	375		}
333	376		}
	377	+
	378	+	waitForExpectations(timeout: 1)
334	379		}
335	380
336	381		/// Test whether we can make a successfull rekognition call to identify entities

343	388		///
344	389		func testIdentifyEntitiesService() {
345	390		setUpAmplify()
	391	+
346	392		let mockResponse: AWSRekognitionDetectFacesResponse = AWSRekognitionDetectFacesResponse()
347	393		mockResponse.faceDetails = [AWSRekognitionFaceDetail]()
348	394

12	12
13	13		class MockTranscribeBehavior: AWSTranscribeStreamingBehavior {
14	14
	15	+	var delegate: AWSTranscribeStreamingClientDelegate?
	16	+	var callbackQueue: DispatchQueue?
15	17		var transcriptionResult: AWSTranscribeStreamingTranscriptResultStream?
16	18		var error: Error?
17	19

26	28
27	29		public func setResult(result: AWSTranscribeStreamingTranscriptResultStream?) {
28	30		transcriptionResult = result
	31	+	error = nil
29	32		}
30	33
31	34		func startTranscriptionWSS(request: AWSTranscribeStreamingStartStreamTranscriptionRequest) {
32		-
	35	+	delegate?.didReceiveEvent(transcriptionResult, decodingError: error)
33	36		}
34	37
35	38		func setDelegate(delegate: AWSTranscribeStreamingClientDelegate, callbackQueue: DispatchQueue) {
36		-
	39	+	self.delegate = delegate
	40	+	self.callbackQueue = callbackQueue
37	41		}
38	42
39	43		func send(data: Data, headers: [String: String]) {

78	78		///
79	79		func testIdentifyLabelsService() {
80	80		setUpAmplify()
	81	+
	82	+	let resultReceived = expectation(description: "Transcription result should be returned")
81	83		let mockResponse: AWSRekognitionDetectLabelsResponse = AWSRekognitionDetectLabelsResponse()
82	84		mockResponse.labels = [AWSRekognitionLabel]()
83	85

94	96		let labelResult = result as? IdentifyLabelsResult
95	97		let labels = IdentifyLabelsResultTransformers.processLabels(mockResponse.labels!)
96	98		XCTAssertEqual(labelResult?.labels, labels, "Labels should be the same")
	99	+	resultReceived.fulfill()
97	100		case .failed(let error):
98	101		XCTFail("Should not produce error: \(error)")
99	102		}
100	103		}
	104	+
	105	+	waitForExpectations(timeout: 1)
101	106		}
102	107
103	108		/// Test whether error is correctly propogated

110	115		///
111	116		func testIdentifyLabelsServiceWithError() {
112	117		setUpAmplify()
	118	+
	119	+	let errorReceived = expectation(description: "Error should be returned")
113	120		let mockError = NSError(domain: AWSRekognitionErrorDomain,
114	121		code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
115	122		userInfo: [:])

136	146		///
137	147		func testIdentifyLabelsServiceWithNilResponse() {
138	148		setUpAmplify()
139		-
140	149		mockRekognition.setLabelsResponse(result: nil)
	150	+
	151	+	let errorReceived = expectation(description: "Error should be returned")
141	152		let testBundle = Bundle(for: type(of: self))
142	153		guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
143	154		XCTFail("Unable to find image")

164	178		///
165	179		func testIdentifyModerationLabelsService() {
166	180		setUpAmplify()
	181	+
	182	+	let resultReceived = expectation(description: "Transcription result should be returned")
167	183		let mockResponse: AWSRekognitionDetectModerationLabelsResponse = AWSRekognitionDetectModerationLabelsResponse()
168	184		mockResponse.moderationLabels = [AWSRekognitionModerationLabel]()
169	185

224	248		///
225	249		func testIdentifyModerationLabelsServiceWithNilResponse() {
226	250		setUpAmplify()
227		-
228	251		mockRekognition.setModerationLabelsResponse(result: nil)
	252	+
	253	+	let errorReceived = expectation(description: "Error should be returned")
229	254		let testBundle = Bundle(for: type(of: self))
230	255		guard let url = testBundle.url(forResource: "testImageLabels", withExtension: "jpg") else {
231	256		XCTFail("Unable to find image")

252	280		///
253	281		func testIdentifyAllLabelsService() {
254	282		setUpAmplify()
	283	+
	284	+	let resultReceived = expectation(description: "Transcription result should be returned")
255	285		let mockLabelsResponse: AWSRekognitionDetectLabelsResponse = AWSRekognitionDetectLabelsResponse()
256	286		mockLabelsResponse.labels = [AWSRekognitionLabel]()
257	287

353	399		return
354	400		}
355	401
	402	+	let resultReceived = expectation(description: "Transcription result should be returned")
	403	+
356	404		predictionsService.detectEntities(image: url) { event in
357	405		switch event {
358	406		case .completed(let result):
359	407		let entitiesResult = result as? IdentifyEntitiesResult
360	408		let newFaces = IdentifyEntitiesResultTransformers.processFaces(mockResponse.faceDetails!)
361	409		XCTAssertEqual(entitiesResult?.entities.count, newFaces.count, "Faces count number should be the same")
	410	+	resultReceived.fulfill()
362	411		case .failed(let error):
363	412		XCTFail("Should not produce error: \(error)")
364	413		}
365	414		}
	415	+
	416	+	waitForExpectations(timeout: 1)
366	417		}
367	418
368	419		/// Test whether error is correctly propogated for detecting entities

428	489		///
429	490		func testIdentifyEntityMatchesService() {
430	491		setUpAmplify(withCollection: true)
	492	+
431	493		let mockResponse: AWSRekognitionSearchFacesByImageResponse = AWSRekognitionSearchFacesByImageResponse()
432	494		mockResponse.faceMatches = [AWSRekognitionFaceMatch]()
433	495

513	589		///
514	590		func testIdentifyPlainTextService() {
515	591		setUpAmplify()
	592	+
516	593		let mockResponse: AWSRekognitionDetectTextResponse = AWSRekognitionDetectTextResponse()
517	594		mockResponse.textDetections = [AWSRekognitionTextDetection]()
518	595

586	673		XCTFail("Should not produce result: \(result)")
587	674		case .failed(let error):
588	675		XCTAssertNotNil(error, "Should produce an error")
	676	+	errorReceived.fulfill()
589	677		}
590	678		}
	679	+
	680	+	waitForExpectations(timeout: 1)
591	681		}
592	682		}

375	426		///
376	427		func testIdentifyEntitiesServiceWithError() {
377	428		setUpAmplify()
	429	+
378	430		let mockError = NSError(domain: AWSRekognitionErrorDomain,
379	431		code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
380	432		userInfo: [:])
381	433		mockRekognition.setError(error: mockError)
382	434		let url = URL(fileURLWithPath: "")
	435	+	let errorReceived = expectation(description: "Error should be returned")
383	436
384	437		predictionsService.detectEntities(image: url) { event in
385	438		switch event {

402	458		func testIdentifyEntitiesServiceWithNilResponse() {
403	459		setUpAmplify()
404	460		mockRekognition.setFacesResponse(result: nil)
	461	+
405	462		let testBundle = Bundle(for: type(of: self))
406	463		guard let url = testBundle.url(forResource: "testImageEntities", withExtension: "jpg") else {
407	464		XCTFail("Unable to find image")
408	465		return
409	466		}
	467	+	let errorReceived = expectation(description: "Error should be returned")
410	468
411	469		predictionsService.detectEntities(image: url) { event in
412	470		switch event {

460	526		///
461	527		func testIdentifyEntityMatchesServiceWithError() {
462	528		setUpAmplify(withCollection: true)
	529	+
463	530		let mockError = NSError(domain: AWSRekognitionErrorDomain,
464	531		code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
465	532		userInfo: [:])
466	533		mockRekognition.setError(error: mockError)
467	534		let url = URL(fileURLWithPath: "")
	535	+	let errorReceived = expectation(description: "Error should be returned")
468	536
469	537		predictionsService.detectEntities(image: url) { event in
470	538		switch event {

487	558		func testIdentifyEntityMatchesServiceWithNilResponse() {
488	559		setUpAmplify(withCollection: true)
489	560		mockRekognition.setFacesFromCollection(result: nil)
	561	+
490	562		let testBundle = Bundle(for: type(of: self))
491	563		guard let url = testBundle.url(forResource: "testImageEntities", withExtension: "jpg") else {
492	564		XCTFail("Unable to find image")
493	565		return
494	566		}
	567	+	let errorReceived = expectation(description: "Error should be returned")
495	568
496	569		predictionsService.detectEntities(image: url) { event in
497	570		switch event {

530	608		let newText = IdentifyTextResultTransformers.processText(mockResponse.textDetections!)
531	609		XCTAssertEqual(textResult?.identifiedLines?.count,
532	610		newText.identifiedLines?.count, "Text line count number should be the same")
	611	+	resultReceived.fulfill()
533	612		case .failed(let error):
534	613		XCTFail("Should not produce error: \(error)")
535	614		}
536	615		}
	616	+
	617	+	waitForExpectations(timeout: 1)
537	618		}
538	619
539	620		/// Test whether error is correctly propogated for text matches

546	627		///
547	628		func testIdentifyPlainTextServiceWithError() {
548	629		setUpAmplify()
	630	+
549	631		let mockError = NSError(domain: AWSRekognitionErrorDomain,
550	632		code: AWSRekognitionErrorType.invalidImageFormat.rawValue,
551	633		userInfo: [:])
552	634		mockRekognition.setError(error: mockError)
553	635		let url = URL(fileURLWithPath: "")
	636	+	let errorReceived = expectation(description: "Error should be returned")
554	637
555	638		predictionsService.detectText(image: url, format: .plain) { event in
556	639		switch event {

17	17		var error: Error?
18	18
19	19		func analyzeDocument(request: AWSTextractAnalyzeDocumentRequest) -> AWSTask<AWSTextractAnalyzeDocumentResponse> {
20		-	if let finalResult = analyzeDocument {
21		-	return AWSTask(result: finalResult)
	20	+	guard let finalError = error else {
	21	+	return AWSTask(result: analyzeDocument)
22	22		}
23		-	return AWSTask(error: error!)
	23	+	return AWSTask(error: finalError)
24	24		}
25	25
26	26		func detectDocumentText(request: AWSTextractDetectDocumentTextRequest)
27		-	-> AWSTask<AWSTextractDetectDocumentTextResponse> {
28		-	if let finalResult = detectDocumentText {
29		-	return AWSTask(result: finalResult)
30		-	}
31		-	return AWSTask(error: error!)
	27	+	-> AWSTask<AWSTextractDetectDocumentTextResponse> {
	28	+	guard let finalError = error else {
	29	+	return AWSTask(result: detectDocumentText)
	30	+	}
	31	+	return AWSTask(error: finalError)
32	32		}
33	33
34	34		func getTextract() -> AWSTextract {

12	12		import Foundation
13	13		@testable import AWSPredictionsPlugin
14	14
15		-	class PredictionsServiceTextractTests: XCTest {
	15	+	class PredictionsServiceTextractTests: XCTestCase {
16	16		var predictionsService: AWSPredictionsService!
17	17		let mockTextract = MockTextractBehavior()
18	18

59	59		mockTextract.setAnalyzeDocument(result: mockResponse)
60	60		let testBundle = Bundle(for: type(of: self))
61	61		guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
62		-	XCTFail("Unable to find image")
63		-	return
	62	+	XCTFail("Unable to find image")
	63	+	return
64	64		}
	65	+	let resultReceived = expectation(description: "Transcription result should be returned")
65	66
66	67		predictionsService.detectText(image: url, format: .table) { event in
67	68		switch event {
68	69		case .completed(let result):
69		-	let textResult = result as? IdentifyTextResult
	70	+	let textResult = result as? IdentifyDocumentTextResult
70	71		let text = IdentifyTextResultTransformers.processText(mockResponse.blocks!)
71		-	XCTAssertEqual(textResult?.identifiedLines?.count,
	72	+	XCTAssertEqual(textResult?.identifiedLines.count,
72	73		text.identifiedLines.count, "Line count should be the same")
	74	+	resultReceived.fulfill()
73	75		case .failed(let error):
74	76		XCTFail("Should not produce error: \(error)")
75	77		}
76	78		}
	79	+
	80	+	waitForExpectations(timeout: 1)
77	81		}
78	82
79	83		/// Test whether error is correctly propogated for text matches

90	94		userInfo: [:])
91	95		mockTextract.setError(error: mockError)
92	96		let url = URL(fileURLWithPath: "")
	97	+	let errorReceived = expectation(description: "Error should be returned")
93	98
94		-	predictionsService.detectText(image: url, format: .table) { event in
	99	+	predictionsService.detectText(image: url, format: .table) { event in
95	100		switch event {
96	101		case .completed(let result):
97	102		XCTFail("Should not produce result: \(result)")
98	103		case .failed(let error):
99	104		XCTAssertNotNil(error, "Should produce an error")
	105	+	errorReceived.fulfill()
100	106		}
101	107		}
	108	+
	109	+	waitForExpectations(timeout: 1)
102	110		}
103	111
104	112		/// Test whether error is correctly propogated for text matches with nil response

No yaml found.

110	118		/// - I should get back a service error
111	119		///
112	120		func testIdentifyTablesServiceWithNilResponse() {
113		-
114	121		mockTextract.setAnalyzeDocument(result: nil)
115		-	let testBundle = Bundle(for: type(of: self))
116		-	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
117		-	XCTFail("Unable to find image")
118		-	return
119		-	}
120		-	predictionsService.detectText(image: url, format: .table) { event in
	122	+	let testBundle = Bundle(for: type(of: self))
	123	+	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
	124	+	XCTFail("Unable to find image")
	125	+	return
	126	+	}
	127	+	let errorReceived = expectation(description: "Error should be returned")
	128	+
	129	+	predictionsService.detectText(image: url, format: .table) { event in
121	130		switch event {
122	131		case .completed(let result):
123	132		XCTFail("Should not produce result: \(result)")
124	133		case .failed(let error):
125	134		XCTAssertNotNil(error, "Should produce an error")
	135	+	errorReceived.fulfill()
126	136		}
127	137		}
	138	+
	139	+	waitForExpectations(timeout: 1)
128	140		}
129	141
130	142		/// Test whether we can make a successfull textract call to identify forms

193	213		/// - I should get back a service error because response is nil
194	214		///
195	215		func testIdentifyFormsServiceWithNilResponse() {
196		-
197	216		mockTextract.setAnalyzeDocument(result: nil)
198		-	let testBundle = Bundle(for: type(of: self))
199		-	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
200		-	XCTFail("Unable to find image")
201		-	return
202		-	}
	217	+	let testBundle = Bundle(for: type(of: self))
	218	+	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
	219	+	XCTFail("Unable to find image")
	220	+	return
	221	+	}
	222	+	let errorReceived = expectation(description: "Error should be returned")
	223	+
203	224		predictionsService.detectText(image: url, format: .form) { event in
204	225		switch event {
205	226		case .completed(let result):
206	227		XCTFail("Should not produce result: \(result)")
207	228		case .failed(let error):
208	229		XCTAssertNotNil(error, "Should produce an error")
	230	+	errorReceived.fulfill()
209	231		}
210	232		}
	233	+
	234	+	waitForExpectations(timeout: 1)
211	235		}
212	236
213	237		/// Test whether we can make a successfull textract call to identify forms and tables

276	308		/// - I should get back a service error because response is nil
277	309		///
278	310		func testIdentifyAllTextServiceWithNilResponse() {
279		-
280	311		mockTextract.setAnalyzeDocument(result: nil)
281		-	let testBundle = Bundle(for: type(of: self))
282		-	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
283		-	XCTFail("Unable to find image")
284		-	return
285		-	}
	312	+	let testBundle = Bundle(for: type(of: self))
	313	+	guard let url = testBundle.url(forResource: "testImageText", withExtension: "jpg") else {
	314	+	XCTFail("Unable to find image")
	315	+	return
	316	+	}
	317	+	let errorReceived = expectation(description: "Error should be returned")
	318	+
286	319		predictionsService.detectText(image: url, format: .all) { event in
287	320		switch event {
288	321		case .completed(let result):
289	322		XCTFail("Should not produce result: \(result)")
290	323		case .failed(let error):
291	324		XCTAssertNotNil(error, "Should produce an error")
	325	+	errorReceived.fulfill()
292	326		}
293	327		}
	328	+
	329	+	waitForExpectations(timeout: 1)
294	330		}
295	331		}

59	59		english.languageCode = "en"
60	60		english.score = 0.5
61	61		let mockDominantLanguage = mockDominantLanguageResult([english])
	62	+
	63	+	let resultReceived = expectation(description: "Transcription result should be returned")
	64	+
62	65		mockComprehend.setResult(languageResponse: mockDominantLanguage)
63	66		predictionsService.comprehend(text: inputForTest) { event in
64	67		switch event {
65	68		case .completed(let result):
66	69		XCTAssertNotNil(result, "Result should be non-nil")
67	70		XCTAssertEqual(result.language?.languageCode, .english, "Dominant language should match")
	71	+	resultReceived.fulfill()
68	72		case .failed(let error):
69	73		XCTFail("Should not produce error: \(error)")
70	74		}
71	75		}
	76	+
	77	+	waitForExpectations(timeout: 1)
72	78		}
73	79
74	80		/// Test whether we get correct dominant language for multiple languages

89	95		let italian = AWSComprehendDominantLanguage()!
90	96		italian.languageCode = "it"
91	97		italian.score = 0.6
	98	+
92	99		let mockDominantLanguage = mockDominantLanguageResult([english, spanish, italian])
	100	+	let resultReceived = expectation(description: "Transcription result should be returned")
	101	+
93	102		mockComprehend.setResult(languageResponse: mockDominantLanguage)
94	103		predictionsService.comprehend(text: inputForTest) { event in
95	104		switch event {
96	105		case .completed(let result):
97	106		XCTAssertNotNil(result, "Result should be non-nil")
98	107		XCTAssertEqual(result.language?.languageCode, .italian, "Dominant language should match")
	108	+	resultReceived.fulfill()
99	109		case .failed(let error):
100	110		XCTFail("Should not produce error: \(error)")
101	111		}
102	112		}
	113	+
	114	+	waitForExpectations(timeout: 1)
103	115		}
104	116
105	117		/// Test whether empty result from service gives us error

112	124		///
113	125		func testWithEmptyLanguageResult() {
114	126		let mockDominantLanguage = mockDominantLanguageResult()
	127	+	let errorReceived = expectation(description: "Error should be returned")
	128	+
115	129		mockComprehend.setResult(languageResponse: mockDominantLanguage)
116	130		predictionsService.comprehend(text: inputForTest) { event in
117	131		switch event {

119	133		XCTFail("Should not produce result if the service cannot find the language. \(result)")
120	134		case .failed(let error):
121	135		XCTAssertNotNil(error, "Should return an error if language is nil. \(error)")
	136	+	errorReceived.fulfill()
122	137		}
123	138		}
	139	+
	140	+	waitForExpectations(timeout: 1)
124	141		}
125	142
126	143		/// Test whether returninng all nil from service gives us an error

132	149		/// - I should get an error
133	150		///
134	151		func testAllNilResult() {
	152	+	let errorReceived = expectation(description: "Error should be returned")
	153	+
135	154		mockComprehend.setResult()
136	155		predictionsService.comprehend(text: inputForTest) { event in
137	156		switch event {

155	177		let mockError = NSError(domain: AWSComprehendErrorDomain,
156	178		code: AWSComprehendErrorType.internalServer.rawValue,
157	179		userInfo: [:])
	180	+	let errorReceived = expectation(description: "Error should be returned")
	181	+
158	182		mockComprehend.setError(error: mockError)
159	183		predictionsService.comprehend(text: inputForTest) { event in
160	184		switch event {

210	237		keyPhrase.endOffset = 3
211	238		keyPhrase.score = 0.8
212	239		keyPhrase.text = "some text"
	240	+
213	241		let mockKeyPhrases = mockKeyPhrasesResult([keyPhrase])
	242	+	let resultReceived = expectation(description: "Transcription result should be returned")
214	243
215	244		mockComprehend.setResult(sentimentResponse: mockSentiment,
216	245		entitiesResponse: mockEntities,