[FormRecognizer] Filling gaps in our tests (#12926)

* Created content-detection tests

* Added single blank page tests

* Added Jpg content test

* Renamed receipt test to ReceiptJpg

* Added receipt test to ReceiptPng

* Made Form1 custom with labels test take includeTextContent

* Made Form1 custom without labels test take includeTextContent

* Made MultipageFormWithBlankPage with labels tests take uri

* Made MultipageFormWithBlankPage without labels tests take uri

* Enabled multipage form stream test without labels

* Added Invalid Prefix test

* Added bad region CopyModel test

* Added test for deleting model that doesn't exist

* Added fake API key tests

sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientMockTests.cs

@@ -3,9 +3,11 @@
 
 using System;
 using System.IO;
+using System.Linq;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Azure.AI.FormRecognizer.Models;
 using Azure.Core;
 using Azure.Core.TestFramework;
 using NUnit.Framework;
@@ -41,6 +43,45 @@ private FormRecognizerClient CreateInstrumentedClient(FormRecognizerClientOption
             return InstrumentClient(client);
         }
 
+        [Test]
+        public async Task StartRecognizeContentSendsUserSpecifiedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/layout/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            var recognizeOptions = new RecognizeOptions { ContentType = FormContentType.Jpeg };
+            await client.StartRecognizeContentAsync(stream, recognizeOptions);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/jpeg", contentType);
+        }
+
+        [Test]
+        public async Task StartRecognizeContentSendsAutoDetectedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/layout/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            await client.StartRecognizeContentAsync(stream);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/tiff", contentType);
+        }
+
         [Test]
         public async Task StartRecognizeContentFromUriEncodesBlankSpaces()
         {
@@ -68,6 +109,45 @@ public async Task StartRecognizeContentFromUriEncodesBlankSpaces()
             }
         }
 
+        [Test]
+        public async Task StartRecognizeReceiptsSendsUserSpecifiedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/prebuilt/receipt/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            var recognizeOptions = new RecognizeOptions { ContentType = FormContentType.Jpeg };
+            await client.StartRecognizeReceiptsAsync(stream, recognizeOptions);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/jpeg", contentType);
+        }
+
+        [Test]
+        public async Task StartRecognizeReceiptsSendsAutoDetectedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/prebuilt/receipt/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            await client.StartRecognizeReceiptsAsync(stream);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/tiff", contentType);
+        }
+
         [Test]
         public async Task StartRecognizeReceiptsFromUriEncodesBlankSpaces()
         {
@@ -95,6 +175,45 @@ public async Task StartRecognizeReceiptsFromUriEncodesBlankSpaces()
             }
         }
 
+        [Test]
+        public async Task StartRecognizeCustomFormsSendsUserSpecifiedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/custom/models/00000000000000000000000000000000/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            var recognizeOptions = new RecognizeOptions { ContentType = FormContentType.Jpeg };
+            await client.StartRecognizeCustomFormsAsync("00000000000000000000000000000000", stream, recognizeOptions);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/jpeg", contentType);
+        }
+
+        [Test]
+        public async Task StartRecognizeCustomFormsSendsAutoDetectedContentType()
+        {
+            var mockResponse = new MockResponse(202);
+            mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/custom/models/00000000000000000000000000000000/analyzeResults/00000000000000000000000000000000"));
+
+            var mockTransport = new MockTransport(new[] { mockResponse, mockResponse });
+            var options = new FormRecognizerClientOptions() { Transport = mockTransport };
+            var client = CreateInstrumentedClient(options);
+
+            using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceLeTiff);
+            await client.StartRecognizeCustomFormsAsync("00000000000000000000000000000000", stream);
+
+            var request = mockTransport.Requests.Single();
+
+            Assert.True(request.Headers.TryGetValue("Content-Type", out var contentType));
+            Assert.AreEqual("image/tiff", contentType);
+        }
+
         [Test]
         public async Task StartRecognizeCustomFormsFromUriEncodesBlankSpaces()
         {

sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormTrainingClient/FormTrainingClientLiveTests.cs

@@ -27,6 +27,13 @@ public FormTrainingClientLiveTests(bool isAsync) : base(isAsync)
         {
         }
 
+        [Test]
+        public void FormTrainingClientCannotAuthenticateWithFakeApiKey()
+        {
+            var client = CreateInstrumentedFormTrainingClient(apiKey: "fakeKey");
+            Assert.ThrowsAsync<RequestFailedException>(async () => await client.GetAccountPropertiesAsync());
+        }
+
         [Test]
         public async Task FormTrainingClientCanAuthenticateWithTokenCredential()
         {
@@ -89,6 +96,20 @@ public async Task StartTraining(bool labeled)
             }
         }
 
+        [Test]
+        public async Task StartTrainingFailsWithInvalidPrefix()
+        {
+            var client = CreateInstrumentedFormTrainingClient();
+            var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl);
+            TrainingOperation operation;
+
+            var filter = new TrainingFileFilter { IncludeSubFolders = true, Prefix = "invalidPrefix" };
+
+            operation = await client.StartTrainingAsync(trainingFilesUri, useTrainingLabels: false, filter);
+
+            Assert.ThrowsAsync<RequestFailedException>(async () => await operation.WaitForCompletionAsync(PollingInterval));
+        }
+
         [Test]
         public async Task StartTrainingError()
         {
@@ -171,6 +192,15 @@ public async Task TrainingOps(bool labeled)
             Assert.ThrowsAsync<RequestFailedException>(() => client.GetCustomModelAsync(trainedModel.ModelId));
         }
 
+        [Test]
+        public void DeleteModelFailsWhenModelDoesNotExist()
+        {
+            var client = CreateInstrumentedFormTrainingClient();
+            var fakeModelId = "00000000-0000-0000-0000-000000000000";
+
+            Assert.ThrowsAsync<RequestFailedException>(async () => await client.DeleteModelAsync(fakeModelId));
+        }
+
         [Test]
         public async Task CopyModel()
         {
@@ -210,6 +240,22 @@ public void CopyModelError()
             Assert.ThrowsAsync<RequestFailedException>(async () => await sourceClient.StartCopyModelAsync("00000000-0000-0000-0000-000000000000", targetAuth));
         }
 
+        [Test]
+        public async Task StartCopyModelFailsWithWrongRegion()
+        {
+            var sourceClient = CreateInstrumentedFormTrainingClient();
+            var targetClient = CreateInstrumentedFormTrainingClient();
+            var resourceID = TestEnvironment.TargetResourceId;
+            var wrongRegion = TestEnvironment.TargetResourceRegion == "westcentralus" ? "eastus2" : "westcentralus";
+
+            await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: true);
+            CopyAuthorization targetAuth = await targetClient.GetCopyAuthorizationAsync(resourceID, wrongRegion);
+
+            var operation = await sourceClient.StartCopyModelAsync(trainedModel.ModelId, targetAuth);
+
+            Assert.ThrowsAsync<RequestFailedException>(async () => await operation.WaitForCompletionAsync(PollingInterval));
+        }
+
         [Test]
         public async Task GetCopyAuthorization()
         {

sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/FormRecognizerLiveTestBase.cs

@@ -23,8 +23,9 @@ public FormRecognizerLiveTestBase(bool isAsync) : base(isAsync)
         /// variables and instruments it to make use of the Azure Core Test Framework functionalities.
         /// </summary>
         /// <param name="useTokenCredential">Whether or not to use a <see cref="TokenCredential"/> to authenticate. An <see cref="AzureKeyCredential"/> is used by default.</param>
+        /// <param name="apiKey">The API key to use for authentication. Defaults to <see cref="FormRecognizerTestEnvironment.ApiKey"/>.</param>
         /// <returns>The instrumented <see cref="FormTrainingClient" />.</returns>
-        protected FormTrainingClient CreateInstrumentedFormTrainingClient(bool useTokenCredential = false)
+        protected FormTrainingClient CreateInstrumentedFormTrainingClient(bool useTokenCredential = false, string apiKey = default)
         {
             var endpoint = new Uri(TestEnvironment.Endpoint);
             var options = Recording.InstrumentClientOptions(new FormRecognizerClientOptions());
@@ -36,7 +37,7 @@ protected FormTrainingClient CreateInstrumentedFormTrainingClient(bool useTokenC
             }
             else
             {
-                var credential = new AzureKeyCredential(TestEnvironment.ApiKey);
+                var credential = new AzureKeyCredential(apiKey ?? TestEnvironment.ApiKey);
                 client = new FormTrainingClient(endpoint, credential, options);
             }