diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisClient/DocumentAnalysisClientLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisClient/DocumentAnalysisClientLiveTests.cs index 5a0d60241b9c..4d3feeec45ec 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisClient/DocumentAnalysisClientLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisClient/DocumentAnalysisClientLiveTests.cs @@ -443,54 +443,6 @@ public async Task AnalyzeDocumentWithCustomModelCanParseDifferentTypeOfForm() field.FieldType == DocumentFieldType.Unknown && field.ExpectedFieldType == DocumentFieldType.String)); } - [RecordedTest] - public async Task AnalyzeDocumentWithCustomModelWithTableDynamicRows() - { - var client = CreateDocumentAnalysisClient(); - var modelId = Recording.GenerateId(); - AnalyzeDocumentOperation operation; - - await using var customModel = await BuildDisposableDocumentModelAsync(modelId, ContainerType.TableVariableRows); - - using var stream = DocumentAnalysisTestEnvironment.CreateStream(TestFile.FormTableDynamicRows); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, customModel.ModelId, stream); - } - - AnalyzeResult result = operation.Value; - - ValidateAnalyzeResult( - result, - customModel.ModelId, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1); - } - - [RecordedTest] - public async Task AnalyzeDocumentWithCustomModelWithTableFixedRows() - { - var client = CreateDocumentAnalysisClient(); - var modelId = Recording.GenerateId(); - AnalyzeDocumentOperation operation; - - await using var customModel = await BuildDisposableDocumentModelAsync(modelId, ContainerType.TableFixedRows); - - using var stream = DocumentAnalysisTestEnvironment.CreateStream(TestFile.FormTableFixedRows); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.AnalyzeDocumentAsync(WaitUntil.Completed, customModel.ModelId, stream); - } - - AnalyzeResult result = operation.Value; - - ValidateAnalyzeResult( - result, - customModel.ModelId, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1); - } - [RecordedTest] [Ignore("Service error. Issue https://github.com/Azure/azure-sdk-for-net/issues/24995")] public async Task AnalyzeDocumentWithCustomModelCanParseBlankPage() diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsLiveTests.cs index 780378b2d6fd..da746cd3181d 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsLiveTests.cs @@ -7,8 +7,6 @@ using Azure.Core.TestFramework; using NUnit.Framework; -using TestFile = Azure.AI.FormRecognizer.Tests.TestFile; - namespace Azure.AI.FormRecognizer.DocumentAnalysis.Tests { /// @@ -30,39 +28,6 @@ public OperationsLiveTests(bool isAsync, DocumentAnalysisClientOptions.ServiceVe { } - [RecordedTest] - public async Task AnalyzeDocumentOperationCanPollFromNewObject() - { - var client = CreateDocumentAnalysisClient(out var nonInstrumentedClient); - - var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.ReceiptJpg); - var operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Started, "prebuilt-receipt", uri); - Assert.IsNotNull(operation.GetRawResponse()); - - var sameOperation = InstrumentOperation(new AnalyzeDocumentOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(1, sameOperation.Value.Pages.Count); - } - - [RecordedTest] - public async Task BuildModelOperationCanPollFromNewObject() - { - var client = CreateDocumentModelAdministrationClient(out var nonInstrumentedClient); - var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl); - var modelId = Recording.GenerateId(); - - var operation = await client.BuildDocumentModelAsync(WaitUntil.Started, trainingFilesUri, DocumentBuildMode.Template, modelId); - Assert.IsNotNull(operation.GetRawResponse()); - - var sameOperation = InstrumentOperation(new BuildDocumentModelOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(modelId, sameOperation.Value.ModelId); - } - [RecordedTest] public async Task BuildModelOperationPercentageCompletedValue() { @@ -79,27 +44,6 @@ public async Task BuildModelOperationPercentageCompletedValue() Assert.AreEqual(100, operation.PercentCompleted); } - [RecordedTest] - public async Task CopyModelToOperationCanPollFromNewObject() - { - var client = CreateDocumentModelAdministrationClient(out var nonInstrumentedClient); - var modelId = Recording.GenerateId(); - - await using var trainedModel = await BuildDisposableDocumentModelAsync(modelId); - - var targetModelId = Recording.GenerateId(); - DocumentModelCopyAuthorization targetAuth = await client.GetCopyAuthorizationAsync(targetModelId); - - var operation = await client.CopyDocumentModelToAsync(WaitUntil.Started, trainedModel.ModelId, targetAuth); - Assert.IsNotNull(operation.GetRawResponse()); - - var sameOperation = InstrumentOperation(new CopyDocumentModelToOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(targetModelId, sameOperation.Value.ModelId); - } - [RecordedTest] public async Task CopyModelToOperationPercentageCompletedValue() { @@ -120,62 +64,6 @@ public async Task CopyModelToOperationPercentageCompletedValue() Assert.AreEqual(100, operation.PercentCompleted); } - [RecordedTest] - [ServiceVersion(Min = DocumentAnalysisClientOptions.ServiceVersion.V2023_02_28_Preview)] - public async Task ClassifyDocumentOperationCanPollFromNewObject() - { - var client = CreateDocumentAnalysisClient(out var nonInstrumentedClient); - var classifierId = Recording.GenerateId(); - await using var disposableClassifier = await BuildDisposableDocumentClassifierAsync(classifierId); - var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.Irs1040); - - var operation = await client.ClassifyDocumentFromUriAsync(WaitUntil.Started, classifierId, uri); - var sameOperation = InstrumentOperation(new ClassifyDocumentOperation(operation.Id, nonInstrumentedClient)); - - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(4, sameOperation.Value.Pages.Count); - } - - [RecordedTest] - [ServiceVersion(Min = DocumentAnalysisClientOptions.ServiceVersion.V2023_02_28_Preview)] - public async Task BuildClassifierOperationCanPollFromNewObject() - { - var client = CreateDocumentModelAdministrationClient(out var nonInstrumentedClient); - var classifierId = Recording.GenerateId(); - - var trainingFilesUri = new Uri(TestEnvironment.ClassifierTrainingSasUrl); - var sourceA = new AzureBlobContentSource(trainingFilesUri) { Prefix = "IRS-1040-A/train" }; - var sourceB = new AzureBlobContentSource(trainingFilesUri) { Prefix = "IRS-1040-B/train" }; - - var documentTypes = new Dictionary() - { - { "IRS-1040-A", new ClassifierDocumentTypeDetails(sourceA) }, - { "IRS-1040-B", new ClassifierDocumentTypeDetails(sourceB) } - }; - - BuildDocumentClassifierOperation sameOperation = null; - - try - { - var operation = await client.BuildDocumentClassifierAsync(WaitUntil.Started, documentTypes, classifierId); - - sameOperation = InstrumentOperation(new BuildDocumentClassifierOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - } - finally - { - if (sameOperation != null && sameOperation.HasValue) - { - await client.DeleteDocumentClassifierAsync(classifierId); - } - } - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(classifierId, sameOperation.Value.ClassifierId); - } - [RecordedTest] [ServiceVersion(Min = DocumentAnalysisClientOptions.ServiceVersion.V2023_02_28_Preview)] public async Task BuildClassifierOperationPercentageCompletedValue() diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsMockTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsMockTests.cs index 41941301812d..15759517dc70 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsMockTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/DocumentAnalysisModels/OperationsMockTests.cs @@ -2,13 +2,19 @@ // Licensed under the MIT License. using System; +using System.Collections.Generic; using System.IO; +using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; +using Azure.Core; using Azure.Core.TestFramework; using Azure.Core.Tests; using NUnit.Framework; +using TestFile = Azure.AI.FormRecognizer.Tests.TestFile; + namespace Azure.AI.FormRecognizer.DocumentAnalysis.Tests { /// @@ -20,6 +26,8 @@ public class OperationsMockTests : ClientTestBase private const string AnalyzeOperationId = "00000000000000000000000000000000/analyzeResults/00000000000000000000000000000000"; + private const string OperationLocation = "https://fake.cognitiveservices.azure.com/formrecognizer/documentModels/prebuilt-receipt/analyzeResults/15b885e2-ce22-4499-8d89-822e16a1722a?api-version=2023-02-28-preview"; + /// /// Initializes a new instance of the class. /// @@ -84,6 +92,32 @@ public async Task AnalyzeDocumentOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(AnalyzeDocumentOperation)}.{nameof(AnalyzeDocumentOperation.UpdateStatus)}"); } + [Test] + public async Task AnalyzeDocumentOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, OperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new DocumentAnalysisClientOptions() { Transport = mockTransport }; + var client = CreateDocumentAnalysisClient(options); + + var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.AnalyzeDocumentFromUriAsync(WaitUntil.Started, "modelId", uri); + var sameOperation = new AnalyzeDocumentOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void AnalyzeDocumentOperationArgumentValidation() { @@ -132,6 +166,32 @@ public void AnalyzeDocumentWithError() Assert.IsTrue(ex.Message.Contains("AdditionInformation")); } + [Test] + public async Task BuildDocumentModelOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, OperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new DocumentAnalysisClientOptions() { Transport = mockTransport }; + var client = CreateDocumentModelAdministrationClient(options); + + var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.BuildDocumentModelAsync(WaitUntil.Started, uri, DocumentBuildMode.Neural); + var sameOperation = new BuildDocumentModelOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void BuildModelWithError() { @@ -173,6 +233,33 @@ public void BuildModelWithError() Assert.IsTrue(ex.Message.Contains("AdditionInformation")); } + [Test] + public async Task CopyDocumentModelToOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, OperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new DocumentAnalysisClientOptions() { Transport = mockTransport }; + var client = CreateDocumentModelAdministrationClient(options); + + var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.Blank); + var target = new DocumentModelCopyAuthorization("resourceId", "resourceRegion", "modelId", uri, "token", default); + var operation = await client.CopyDocumentModelToAsync(WaitUntil.Started, "modelId", target); + var sameOperation = new CopyDocumentModelToOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void CopyModelToWithError() { @@ -241,6 +328,32 @@ public async Task ClassifyDocumentOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(ClassifyDocumentOperation)}.{nameof(ClassifyDocumentOperation.UpdateStatus)}"); } + [Test] + public async Task ClassifyDocumentOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, OperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new DocumentAnalysisClientOptions() { Transport = mockTransport }; + var client = CreateDocumentAnalysisClient(options); + + var uri = DocumentAnalysisTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.ClassifyDocumentFromUriAsync(WaitUntil.Started, "modelId", uri); + var sameOperation = new ClassifyDocumentOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public async Task BuildDocumentClassifierOperationCreatesDiagnosticScopeOnUpdate() { @@ -267,5 +380,63 @@ public async Task BuildDocumentClassifierOperationCreatesDiagnosticScopeOnUpdate testListener.AssertScope($"{nameof(BuildDocumentClassifierOperation)}.{nameof(BuildDocumentClassifierOperation.UpdateStatus)}"); } + + [Test] + public async Task BuildDocumentClassifierOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, OperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new DocumentAnalysisClientOptions() { Transport = mockTransport }; + var client = CreateDocumentModelAdministrationClient(options); + + var documentTypes = new Dictionary() + { + { "documentType", new ClassifierDocumentTypeDetails(null, null) } + }; + var operation = await client.BuildDocumentClassifierAsync(WaitUntil.Started, documentTypes); + var sameOperation = new BuildDocumentClassifierOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + + private static string GetString(RequestContent content) + { + if (content == null) + { + return null; + } + + using var stream = new MemoryStream(); + content.WriteTo(stream, CancellationToken.None); + + return Encoding.UTF8.GetString(stream.ToArray()); + } + + private void AssertRequestsAreEqual(MockRequest left, MockRequest right) + { + Assert.AreEqual(left.Uri.ToString(), right.Uri.ToString()); + Assert.AreEqual(left.Method, right.Method); + Assert.AreEqual(GetString(left.Content), GetString(right.Content)); + + var leftHeaders = left.Headers.ToDictionary(h => h.Name, h => h.Value); + var rightHeaders = right.Headers.ToDictionary(h => h.Name, h => h.Value); + + // Removing header excepted to be different for each request. + leftHeaders.Remove("x-ms-client-request-id"); + rightHeaders.Remove("x-ms-client-request-id"); + + CollectionAssert.AreEquivalent(leftHeaders, rightHeaders); + } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientMockTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientMockTests.cs index 7085d208b767..210996a15643 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientMockTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientMockTests.cs @@ -111,6 +111,50 @@ public async Task StartRecognizeContentFromUriEncodesBlankSpaces() } } + [Test] + [TestCase(FormReadingOrder.Basic, "basic")] + [TestCase(FormReadingOrder.Natural, "natural")] + public async Task StartRecognizeContentSendsReadingOrder(FormReadingOrder readingOrder, string readingOrderString) + { + 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.Form1); + var recognizeOptions = new RecognizeContentOptions { ReadingOrder = readingOrder }; + await client.StartRecognizeContentAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"readingOrder={readingOrderString}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase(FormReadingOrder.Basic, "basic")] + [TestCase(FormReadingOrder.Natural, "natural")] + public async Task StartRecognizeContentFromUriSendsReadingOrder(FormReadingOrder readingOrder, string readingOrderString) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeContentOptions { ReadingOrder = readingOrder }; + await client.StartRecognizeContentFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"readingOrder={readingOrderString}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + [Test] [TestCase("")] [TestCase("en")] @@ -135,6 +179,118 @@ public async Task StartRecognizeContentSendsUserSpecifiedLanguage(string languag Assert.AreEqual(language, requestUriQuery.Substring(index + languageQuery.Length, length)); } + [Test] + [TestCase("")] + [TestCase("en")] + public async Task StartRecognizeContentFromUriSendsUserSpecifiedLanguage(string language) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeContentOptions { Language = language }; + await client.StartRecognizeContentFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + + var languageQuery = "language="; + var index = requestUriQuery.IndexOf(languageQuery); + var length = requestUriQuery.Length - (index + languageQuery.Length); + Assert.AreEqual(language, requestUriQuery.Substring(index + languageQuery.Length, length)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeContentSendsOnePageArgument(string pages) + { + 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.Form1); + var recognizeOptions = new RecognizeContentOptions { Pages = { pages } }; + await client.StartRecognizeContentAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeContentFromUriSendsOnePageArgument(string pages) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeContentOptions { Pages = { pages } }; + await client.StartRecognizeContentFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeContentSendsMultiplePageArgument(string page1, string page2) + { + 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.Form1); + var recognizeOptions = new RecognizeContentOptions { Pages = { page1, page2 } }; + await client.StartRecognizeContentAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeContentFromUriSendsMultiplePageArgument(string page1, string page2) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeContentOptions { Pages = { page1, page2 } }; + await client.StartRecognizeContentFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + #endregion #region Recognize Receipt @@ -228,6 +384,118 @@ public async Task StartRecognizeReceiptsSendsUserSpecifiedLocale(string locale) Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); } + [Test] + [TestCase("")] + [TestCase("en-US")] + public async Task StartRecognizeReceiptsFromUriSendsUserSpecifiedLocale(string locale) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeReceiptsOptions { Locale = locale }; + await client.StartRecognizeReceiptsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + + var localeQuery = "locale="; + var index = requestUriQuery.IndexOf(localeQuery); + var length = requestUriQuery.Length - (index + localeQuery.Length); + Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeReceiptsSendsOnePageArgument(string pages) + { + 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.ReceiptJpg); + var recognizeOptions = new RecognizeReceiptsOptions { Pages = { pages } }; + await client.StartRecognizeReceiptsAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeReceiptsFromUriSendsOnePageArgument(string pages) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeReceiptsOptions { Pages = { pages } }; + await client.StartRecognizeReceiptsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeReceiptsSendsMultiplePageArgument(string page1, string page2) + { + 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.ReceiptJpg); + var recognizeOptions = new RecognizeReceiptsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeReceiptsAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeReceiptsFromUriSendsMultiplePageArgument(string page1, string page2) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeReceiptsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeReceiptsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + #endregion #region Recognize Business Cards @@ -321,6 +589,118 @@ public async Task StartRecognizeBusinessCardsSendsUserSpecifiedLocale(string loc Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); } + [Test] + [TestCase("")] + [TestCase("en-US")] + public async Task StartRecognizeBusinessCardsFromUriSendsUserSpecifiedLocale(string locale) + { + var mockResponse = new MockResponse(202); + mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/prebuilt/businesscards/analyzeResults/00000000000000000000000000000000")); + + var mockTransport = new MockTransport(new[] { mockResponse, mockResponse }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateInstrumentedClient(options); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeBusinessCardsOptions { Locale = locale }; + await client.StartRecognizeBusinessCardsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + + var localeQuery = "locale="; + var index = requestUriQuery.IndexOf(localeQuery); + var length = requestUriQuery.Length - (index + localeQuery.Length); + Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeBusinessCardsSendsOnePageArgument(string pages) + { + 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.BusinessCardJpg); + var recognizeOptions = new RecognizeBusinessCardsOptions { Pages = { pages } }; + await client.StartRecognizeBusinessCardsAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeBusinessCardsFromUriSendsOnePageArgument(string pages) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeBusinessCardsOptions { Pages = { pages } }; + await client.StartRecognizeBusinessCardsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeBusinessCardsSendsMultiplePageArgument(string page1, string page2) + { + 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.BusinessCardJpg); + var recognizeOptions = new RecognizeBusinessCardsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeBusinessCardsAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeBusinessCardsFromUriSendsMultiplePageArgument(string page1, string page2) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeBusinessCardsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeBusinessCardsFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + #endregion #region Recognize Invoices @@ -414,6 +794,118 @@ public async Task StartRecognizeInvoicesSendsUserSpecifiedLocale(string locale) Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); } + [Test] + [TestCase("")] + [TestCase("en-US")] + public async Task StartRecognizeInvoicesFromUriSendsUserSpecifiedLocale(string locale) + { + var mockResponse = new MockResponse(202); + mockResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, "host/prebuilt/invoice/analyzeResults/00000000000000000000000000000000")); + + var mockTransport = new MockTransport(new[] { mockResponse, mockResponse }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateInstrumentedClient(options); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeInvoicesOptions { Locale = locale }; + await client.StartRecognizeInvoicesFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + + var localeQuery = "locale="; + var index = requestUriQuery.IndexOf(localeQuery); + var length = requestUriQuery.Length - (index + localeQuery.Length); + Assert.AreEqual(locale, requestUriQuery.Substring(index + localeQuery.Length, length)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeInvoicesSendsOnePageArgument(string pages) + { + 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.InvoiceJpg); + var recognizeOptions = new RecognizeInvoicesOptions { Pages = { pages } }; + await client.StartRecognizeInvoicesAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeInvoicesFromUriSendsOnePageArgument(string pages) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeInvoicesOptions { Pages = { pages } }; + await client.StartRecognizeInvoicesFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeInvoicesSendsMultiplePageArgument(string page1, string page2) + { + 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.InvoiceJpg); + var recognizeOptions = new RecognizeInvoicesOptions { Pages = { page1, page2 } }; + await client.StartRecognizeInvoicesAsync(stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeInvoicesFromUriSendsMultiplePageArgument(string page1, string page2) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeInvoicesOptions { Pages = { page1, page2 } }; + await client.StartRecognizeInvoicesFromUriAsync(uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + #endregion #region Recognize Custom Forms @@ -484,6 +976,94 @@ public async Task StartRecognizeCustomFormsFromUriEncodesBlankSpaces() } } + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeCustomFormsSendsOnePageArgument(string pages) + { + 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.Form1); + var recognizeOptions = new RecognizeCustomFormsOptions { Pages = { pages } }; + await client.StartRecognizeCustomFormsAsync("00000000000000000000000000000000", stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1")] + [TestCase("1-2")] + public async Task StartRecognizeCustomFormsFromUriSendsOnePageArgument(string pages) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeCustomFormsOptions { Pages = { pages } }; + await client.StartRecognizeCustomFormsFromUriAsync("00000000000000000000000000000000", uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={pages}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeCustomFormsSendsMultiplePageArgument(string page1, string page2) + { + 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.Form1); + var recognizeOptions = new RecognizeCustomFormsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeCustomFormsAsync("00000000000000000000000000000000", stream, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + + [Test] + [TestCase("1", "3")] + [TestCase("1-2", "3")] + public async Task StartRecognizeCustomFormsFromUriSendsMultiplePageArgument(string page1, string page2) + { + 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); + + var uri = new Uri("https://fakeuri.com/"); + var recognizeOptions = new RecognizeCustomFormsOptions { Pages = { page1, page2 } }; + await client.StartRecognizeCustomFormsFromUriAsync("00000000000000000000000000000000", uri, recognizeOptions); + + var requestUriQuery = mockTransport.Requests.Single().Uri.Query; + var expectedSubstring = $"pages={page1}%2C{page2}"; + + Assert.True(requestUriQuery.Contains(expectedSubstring)); + } + #endregion private static string GetString(RequestContent content) diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientTests.cs index 10d719bc3d08..73cd6315ad4b 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/FormRecognizerClientTests.cs @@ -47,7 +47,7 @@ private FormRecognizerClient CreateClient() /// The instrumented . private FormRecognizerClient CreateInstrumentedClient() => InstrumentClient(CreateClient()); - #region client + #region Client /// /// Verifies functionality of the constructors. /// diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeBusinessCardsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeBusinessCardsLiveTests.cs index fdc3dbb82d66..2d2146980804 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeBusinessCardsLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeBusinessCardsLiveTests.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using System; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -323,20 +322,6 @@ public async Task StartRecognizeBusinessCardsCanParseBlankPage() Assert.AreEqual(0, blankPage.SelectionMarks.Count); } - [RecordedTest] - public void StartRecognizeBusinessCardsThrowsForDamagedFile() - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeBusinessCardsAsync(stream)); - Assert.AreEqual("BadArgument", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. @@ -413,42 +398,6 @@ public async Task StartRecognizeBusinessCardsCanParseMultipageForm(bool useStrea } } - [RecordedTest] - public async Task StartRecognizeBusinessCardsWithSupportedLocale() - { - var client = CreateFormRecognizerClient(); - var options = new RecognizeBusinessCardsOptions() - { - IncludeFieldElements = true, - Locale = FormRecognizerLocale.EnUS - }; - RecognizeBusinessCardsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.BusinessCardJpg); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeBusinessCardsAsync(stream, options); - } - - RecognizedFormCollection recognizedForms = await operation.WaitForCompletionAsync(); - - var businessCard = recognizedForms.Single(); - - ValidatePrebuiltForm( - businessCard, - includeFieldElements: true, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1); - - Assert.Greater(businessCard.Fields.Count, 0); - - var businessCardPage = businessCard.Pages.Single(); - - Assert.Greater(businessCardPage.Lines.Count, 0); - Assert.AreEqual(0, businessCardPage.SelectionMarks.Count); - Assert.AreEqual(0, businessCardPage.Tables.Count); - } - [RecordedTest] public void StartRecognizeBusinessCardsWithWrongLocale() { @@ -463,43 +412,5 @@ public void StartRecognizeBusinessCardsWithWrongLocale() } Assert.AreEqual("UnsupportedLocale", ex.ErrorCode); } - - [RecordedTest] - [TestCase("1", 1)] - [TestCase("1-2", 2)] - public async Task StartRecognizeBusinessCardsWithOnePageArgument(string pages, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeBusinessCardsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeBusinessCardsAsync(stream, new RecognizeBusinessCardsOptions() { Pages = { pages } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } - - [RecordedTest] - [TestCase("1", "3", 2)] - [TestCase("1-2", "3", 3)] - public async Task StartRecognizeBusinessCardsWithMultiplePageArgument(string page1, string page2, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeBusinessCardsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeBusinessCardsAsync(stream, new RecognizeBusinessCardsOptions() { Pages = { page1, page2 } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeContentLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeContentLiveTests.cs index 8025f085df9c..af6f0c9f7f9d 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeContentLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeContentLiveTests.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using System; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -380,20 +379,6 @@ public async Task StartRecognizeContentCanParseMultipageFormWithBlankPage() Assert.AreEqual(0, blankPage.Tables.Count); } - [RecordedTest] - public void StartRecognizeContentThrowsForDamagedFile() - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeContentAsync(stream)); - Assert.AreEqual("BadArgument", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. @@ -439,64 +424,6 @@ public async Task StartRecognizeContentWithSelectionMarks(bool useStream) ValidateFormPage(formPage, includeFieldElements: true, expectedPageNumber: 1); } - [RecordedTest] - [TestCase("1", 1)] - [TestCase("1-2", 2)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeContentWithOnePageArgument(string pages, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeContentOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeContentAsync(stream, new RecognizeContentOptions() { Pages = { pages } }); - } - - FormPageCollection formPages = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, formPages.Count); - } - - [RecordedTest] - [TestCase("1", "3", 2)] - [TestCase("1-2", "3", 3)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeContentWithMultiplePageArgument(string page1, string page2, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeContentOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeContentAsync(stream, new RecognizeContentOptions() { Pages = { page1, page2 } }); - } - - FormPageCollection formPages = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, formPages.Count); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeContentWithLanguage() - { - var client = CreateFormRecognizerClient(); - RecognizeContentOperation operation; - - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Form1); - operation = await client.StartRecognizeContentFromUriAsync(uri, new RecognizeContentOptions() { Language = FormRecognizerLanguage.En }); - - await operation.WaitForCompletionAsync(); - Assert.IsTrue(operation.HasValue); - - var formPage = operation.Value.Single(); - - ValidateFormPage(formPage, includeFieldElements: true, expectedPageNumber: 1); - } - [RecordedTest] [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] public void StartRecognizeContentWithNoSupporttedLanguage() @@ -507,35 +434,5 @@ public void StartRecognizeContentWithNoSupporttedLanguage() RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeContentFromUriAsync(uri, new RecognizeContentOptions() { Language = "not language" })); Assert.AreEqual("NotSupportedLanguage", ex.ErrorCode); } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeContentWithReadingOrder() - { - var client = CreateFormRecognizerClient(); - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Form1); - RecognizeContentOperation basicOrderOperation, naturalOrderOperation; - - basicOrderOperation = await client.StartRecognizeContentFromUriAsync(uri, new RecognizeContentOptions() { ReadingOrder = FormReadingOrder.Basic }); - naturalOrderOperation = await client.StartRecognizeContentFromUriAsync(uri, new RecognizeContentOptions() { ReadingOrder = FormReadingOrder.Natural }); - - await basicOrderOperation.WaitForCompletionAsync(); - Assert.IsTrue(basicOrderOperation.HasValue); - - await naturalOrderOperation.WaitForCompletionAsync(); - Assert.IsTrue(naturalOrderOperation.HasValue); - - var basicOrderFormPage = basicOrderOperation.Value.Single(); - var naturalOrderFormPage = naturalOrderOperation.Value.Single(); - - ValidateFormPage(basicOrderFormPage, includeFieldElements: true, expectedPageNumber: 1); - ValidateFormPage(naturalOrderFormPage, includeFieldElements: true, expectedPageNumber: 1); - - var basicOrderLines = basicOrderFormPage.Lines.Select(f => f.Text); - var naturalOrderLines = naturalOrderFormPage.Lines.Select(f => f.Text); - - CollectionAssert.AreEquivalent(basicOrderLines, naturalOrderLines); - CollectionAssert.AreNotEqual(basicOrderLines, naturalOrderLines); - } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeCustomFormsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeCustomFormsLiveTests.cs index b730c1f575d1..073dc3ce650c 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeCustomFormsLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeCustomFormsLiveTests.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using System; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -58,8 +57,7 @@ public async Task StartRecognizeCustomFormsCanAuthenticateWithTokenCredential(bo trainedModel.ModelId, includeFieldElements: false, expectedFirstPageNumber: 1, - expectedLastPageNumber: 1, - isComposedModel: false); + expectedLastPageNumber: 1); } else { @@ -115,8 +113,7 @@ public async Task StartRecognizeCustomFormsWithLabels(bool useStream, bool inclu trainedModel.ModelId, includeFieldElements: includeFieldElements, expectedFirstPageNumber: 1, - expectedLastPageNumber: 1, - isComposedModel: false); + expectedLastPageNumber: 1); // Testing that we shuffle things around correctly so checking only once per property. @@ -206,8 +203,7 @@ public async Task StartRecognizeCustomFormsWithLabelsCanParseMultipageForm(bool trainedModel.ModelId, includeFieldElements: true, expectedFirstPageNumber: 1, - expectedLastPageNumber: 2, - isComposedModel: false); + expectedLastPageNumber: 2); // Check some values to make sure that fields from both pages are being populated. @@ -256,8 +252,7 @@ public async Task StartRecognizeCustomFormsWithLabelsCanParseBlankPage() trainedModel.ModelId, includeFieldElements: true, expectedFirstPageNumber: 1, - expectedLastPageNumber: 1, - isComposedModel: false); + expectedLastPageNumber: 1); var blankPage = recognizedForm.Pages.Single(); @@ -299,8 +294,7 @@ public async Task StartRecognizeCustomFormsWithLabelsCanParseMultipageFormWithBl trainedModel.ModelId, includeFieldElements: true, expectedFirstPageNumber: 1, - expectedLastPageNumber: 3, - isComposedModel: false); + expectedLastPageNumber: 3); for (int pageIndex = 0; pageIndex < recognizedForm.Pages.Count; pageIndex++) { @@ -570,25 +564,6 @@ public async Task StartRecognizeCustomFormsWithoutLabelsCanParseMultipageFormWit Assert.AreEqual(0, blankPage.Tables.Count); } - [RecordedTest] - [TestCase(true)] - [TestCase(false)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeCustomFormsThrowsForDamagedFile(bool useTrainingLabels) - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream)); - Assert.AreEqual("1000", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. @@ -608,106 +583,6 @@ public async Task StartRecognizeCustomFormsFromUriThrowsForNonExistingContent(bo Assert.AreEqual("2001", ex.ErrorCode); } - [RecordedTest] - [TestCase("1", 1)] - [TestCase("1-2", 2)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeCustomFormsWithOnePageArgument(string pages, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeCustomFormsOperation operation; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: false, ContainerType.MultipageFiles); - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream, new RecognizeCustomFormsOptions() { Pages = { pages } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } - - [RecordedTest] - [TestCase("1", "3", 2)] - [TestCase("1-2", "3", 3)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeCustomFormsWithMultiplePageArgument(string page1, string page2, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeCustomFormsOperation operation; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: false, ContainerType.MultipageFiles); - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream, new RecognizeCustomFormsOptions() { Pages = { page1, page2 } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeCustomFormsWithTableDynamicRows() - { - var client = CreateFormRecognizerClient(); - RecognizeCustomFormsOperation operation; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: true, ContainerType.TableVariableRows); - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.FormTableDynamicRows); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - RecognizedForm form = forms.Single(); - - ValidateModelWithLabelsForm( - form, - trainedModel.ModelId, - includeFieldElements: false, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1, - isComposedModel: false); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeCustomFormsWithTableFixedRows() - { - var client = CreateFormRecognizerClient(); - RecognizeCustomFormsOperation operation; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: true, ContainerType.TableFixedRows); - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.FormTableFixedRows); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - RecognizedForm form = forms.Single(); - - ValidateModelWithLabelsForm( - form, - trainedModel.ModelId, - includeFieldElements: false, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1, - isComposedModel: false); - } - private void ValidateModelWithNoLabelsForm(RecognizedForm recognizedForm, string modelId, bool includeFieldElements, int expectedFirstPageNumber, int expectedLastPageNumber) { Assert.NotNull(recognizedForm.FormType); @@ -718,16 +593,11 @@ private void ValidateModelWithNoLabelsForm(RecognizedForm recognizedForm, string ValidateRecognizedForm(recognizedForm, includeFieldElements, expectedFirstPageNumber, expectedLastPageNumber); } - private void ValidateModelWithLabelsForm(RecognizedForm recognizedForm, string modelId, bool includeFieldElements, int expectedFirstPageNumber, int expectedLastPageNumber, bool isComposedModel) + private void ValidateModelWithLabelsForm(RecognizedForm recognizedForm, string modelId, bool includeFieldElements, int expectedFirstPageNumber, int expectedLastPageNumber) { Assert.NotNull(recognizedForm.FormType); Assert.IsTrue(recognizedForm.FormTypeConfidence.HasValue); - Assert.IsNotNull(recognizedForm.ModelId); - - if (!isComposedModel) - Assert.AreEqual(modelId, recognizedForm.ModelId); - else - Assert.AreNotEqual(modelId, recognizedForm.ModelId); + Assert.AreEqual(modelId, recognizedForm.ModelId); ValidateRecognizedForm(recognizedForm, includeFieldElements, expectedFirstPageNumber, expectedLastPageNumber); } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeIdentityDocumentsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeIdentityDocumentsLiveTests.cs index ecb8075cdd34..c0dbad720e56 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeIdentityDocumentsLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeIdentityDocumentsLiveTests.cs @@ -2,7 +2,6 @@ // Licensed under the MIT License. using System; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -162,20 +161,6 @@ public async Task StartRecognizeIdentityDocumentsCanParseBlankPage() Assert.IsEmpty(recognizedForms); } - [RecordedTest] - public void StartRecognizeIdentityDocumentsThrowsForDamagedFile() - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeIdentityDocumentsAsync(stream)); - Assert.AreEqual("BadArgument", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeInvoicesLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeInvoicesLiveTests.cs index 258ace413e40..1deaef3327e7 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeInvoicesLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeInvoicesLiveTests.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -332,20 +331,6 @@ public async Task StartRecognizeInvoicesCanParseMultipageForm(bool useStream) expectedLastPageNumber: 2); } - [RecordedTest] - public void StartRecognizeInvoicesThrowsForDamagedFile() - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeInvoicesAsync(stream)); - Assert.AreEqual("BadArgument", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. @@ -360,42 +345,6 @@ public void StartRecognizeInvoicesFromUriThrowsForNonExistingContent() Assert.AreEqual("InvalidImage", ex.ErrorCode); } - [RecordedTest] - public async Task StartRecognizeInvoicesWithSupportedLocale() - { - var client = CreateFormRecognizerClient(); - var options = new RecognizeInvoicesOptions() - { - IncludeFieldElements = true, - Locale = FormRecognizerLocale.EnUS - }; - RecognizeInvoicesOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceJpg); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeInvoicesAsync(stream, options); - } - - RecognizedFormCollection recognizedForms = await operation.WaitForCompletionAsync(); - - var invoice = recognizedForms.Single(); - - ValidatePrebuiltForm( - invoice, - includeFieldElements: true, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1); - - Assert.Greater(invoice.Fields.Count, 0); - - var receiptPage = invoice.Pages.Single(); - - Assert.Greater(receiptPage.Lines.Count, 0); - Assert.AreEqual(1, receiptPage.SelectionMarks.Count); - Assert.AreEqual(2, receiptPage.Tables.Count); - } - [RecordedTest] public void StartRecognizeInvoicesWithWrongLocale() { @@ -410,45 +359,5 @@ public void StartRecognizeInvoicesWithWrongLocale() } Assert.AreEqual("UnsupportedLocale", ex.ErrorCode); } - - [RecordedTest] - [TestCase("1", 1)] - [TestCase("1-2", 2)] - public async Task StartRecognizeInvoicesWithOnePageArgument(string pages, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeInvoicesOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeInvoicesAsync(stream, new RecognizeInvoicesOptions() { Pages = { pages } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - int pageCount = forms.Sum(f => f.Pages.Count); - - Assert.AreEqual(expected, pageCount); - } - - [RecordedTest] - [TestCase("1", "3", 2)] - [TestCase("1-2", "3", 3)] - public async Task StartRecognizeInvoicesWithMultiplePageArgument(string page1, string page2, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeInvoicesOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.InvoiceMultipageBlank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeInvoicesAsync(stream, new RecognizeInvoicesOptions() { Pages = { page1, page2 } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - int pageCount = forms.Sum(f => f.Pages.Count); - - Assert.AreEqual(expected, pageCount); - } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeReceiptsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeReceiptsLiveTests.cs index c0ab6349951c..527b4a0b287f 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeReceiptsLiveTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerClient/RecognizeReceiptsLiveTests.cs @@ -3,7 +3,6 @@ using System; using System.Collections.Generic; -using System.IO; using System.Linq; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; @@ -428,21 +427,6 @@ public async Task StartRecognizeReceiptsCanParseMultipageFormWithBlankPage() Assert.AreEqual(0, blankPage.Tables.Count); } - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public void StartRecognizeReceiptsThrowsForDamagedFile() - { - var client = CreateFormRecognizerClient(); - - // First 4 bytes are PDF signature, but fill the rest of the "file" with garbage. - - var damagedFile = new byte[] { 0x25, 0x50, 0x44, 0x46, 0x55, 0x55, 0x55 }; - using var stream = new MemoryStream(damagedFile); - - RequestFailedException ex = Assert.ThrowsAsync(async () => await client.StartRecognizeReceiptsAsync(stream)); - Assert.AreEqual("BadArgument", ex.ErrorCode); - } - /// /// Verifies that the is able to connect to the Form /// Recognizer cognitive service and handle returned errors. @@ -458,43 +442,6 @@ public void StartRecognizeReceiptsFromUriThrowsForNonExistingContent() Assert.AreEqual("InvalidImage", ex.ErrorCode); } - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeReceiptsWithSupportedLocale() - { - var client = CreateFormRecognizerClient(); - var options = new RecognizeReceiptsOptions() - { - IncludeFieldElements = true, - Locale = FormRecognizerLocale.EnUS - }; - RecognizeReceiptsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.ReceiptJpg); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeReceiptsAsync(stream, options); - } - - RecognizedFormCollection recognizedForms = await operation.WaitForCompletionAsync(); - - var receipt = recognizedForms.Single(); - - ValidatePrebuiltForm( - receipt, - includeFieldElements: true, - expectedFirstPageNumber: 1, - expectedLastPageNumber: 1); - - Assert.Greater(receipt.Fields.Count, 0); - - var receiptPage = receipt.Pages.Single(); - - Assert.Greater(receiptPage.Lines.Count, 0); - Assert.AreEqual(0, receiptPage.SelectionMarks.Count); - Assert.AreEqual(0, receiptPage.Tables.Count); - } - [RecordedTest] [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] public void StartRecognizeReceiptsWithWrongLocale() @@ -510,45 +457,5 @@ public void StartRecognizeReceiptsWithWrongLocale() } Assert.AreEqual("UnsupportedLocale", ex.ErrorCode); } - - [RecordedTest] - [TestCase("1", 1)] - [TestCase("1-2", 2)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeReceiptsWithOnePageArgument(string pages, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeReceiptsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.ReceiptMultipage); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeReceiptsAsync(stream, new RecognizeReceiptsOptions() { Pages = { pages } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } - - [RecordedTest] - [TestCase("1", "3", 2)] - [TestCase("1-2", "3", 3)] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task StartRecognizeReceiptsWithMultiplePageArgument(string page1, string page2, int expected) - { - var client = CreateFormRecognizerClient(); - RecognizeReceiptsOperation operation; - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.ReceipMultipageWithBlankPage); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeReceiptsAsync(stream, new RecognizeReceiptsOptions() { Pages = { page1, page2 } }); - } - - RecognizedFormCollection forms = await operation.WaitForCompletionAsync(); - - Assert.AreEqual(expected, forms.Count); - } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/FormRecognizerOperationsLiveTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/FormRecognizerOperationsLiveTests.cs deleted file mode 100644 index f9eff5c60c18..000000000000 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/FormRecognizerOperationsLiveTests.cs +++ /dev/null @@ -1,167 +0,0 @@ -// Copyright (c) Microsoft Corporation. All rights reserved. -// Licensed under the MIT License. - -using System; -using System.Collections.Generic; -using System.Threading.Tasks; -using Azure.AI.FormRecognizer.Models; -using Azure.AI.FormRecognizer.Training; -using Azure.Core.TestFramework; -using NUnit.Framework; - -namespace Azure.AI.FormRecognizer.Tests -{ - /// - /// The suite of tests for the subclasses. - /// - /// - /// These tests have a dependency on live Azure services and may incur costs for the associated - /// Azure subscription. - /// - public class FormRecognizerOperationsLiveTests : FormRecognizerLiveTestBase - { - /// - /// Initializes a new instance of the class. - /// - /// A flag used by the Azure Core Test Framework to differentiate between tests for asynchronous and synchronous methods. - public FormRecognizerOperationsLiveTests(bool isAsync, FormRecognizerClientOptions.ServiceVersion serviceVersion) - : base(isAsync, serviceVersion) - { - } - - [RecordedTest] - public async Task RecognizeContentOperationCanPollFromNewObject() - { - var client = CreateFormRecognizerClient(out var nonInstrumentedClient); - - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); - var operation = await client.StartRecognizeContentFromUriAsync(uri); - - var sameOperation = InstrumentOperation(new RecognizeContentOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(1, sameOperation.Value.Count); - } - - [RecordedTest] - public async Task RecognizeReceiptsOperationCanPollFromNewObject() - { - var client = CreateFormRecognizerClient(out var nonInstrumentedClient); - - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); - var operation = await client.StartRecognizeReceiptsFromUriAsync(uri); - - var sameOperation = InstrumentOperation(new RecognizeReceiptsOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(1, sameOperation.Value.Count); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task RecognizeInvoicesOperationCanPollFromNewObject() - { - var client = CreateFormRecognizerClient(out var nonInstrumentedClient); - - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); - var operation = await client.StartRecognizeInvoicesFromUriAsync(uri); - - var sameOperation = InstrumentOperation(new RecognizeInvoicesOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(1, sameOperation.Value.Count); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task RecognizeIdentityDocumentsOperationCanPollFromNewObject() - { - var client = CreateFormRecognizerClient(out var nonInstrumentedClient); - - var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); - var operation = await client.StartRecognizeIdentityDocumentsFromUriAsync(uri); - - var sameOperation = InstrumentOperation(new RecognizeIdentityDocumentsOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(0, sameOperation.Value.Count); - } - - [RecordedTest] - public async Task RecognizeCustomFormsOperationCanPollFromNewObject() - { - var client = CreateFormRecognizerClient(out var nonInstrumentedClient); - RecognizeCustomFormsOperation operation; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: false); - - using var stream = FormRecognizerTestEnvironment.CreateStream(TestFile.Blank); - using (Recording.DisableRequestBodyRecording()) - { - operation = await client.StartRecognizeCustomFormsAsync(trainedModel.ModelId, stream); - } - - var sameOperation = InstrumentOperation(new RecognizeCustomFormsOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(1, sameOperation.Value.Count); - } - - [RecordedTest] - public async Task TrainingOperationCanPollFromNewObject() - { - var client = CreateFormTrainingClient(out var nonInstrumentedClient); - var trainingFilesUri = new Uri(TestEnvironment.BlobContainerSasUrl); - - var operation = await client.StartTrainingAsync(trainingFilesUri, useTrainingLabels: false); - - var sameOperation = InstrumentOperation(new TrainingOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(CustomFormModelStatus.Ready, sameOperation.Value.Status); - } - - [RecordedTest] - [ServiceVersion(Min = FormRecognizerClientOptions.ServiceVersion.V2_1)] - public async Task CreateComposedModelOperationCanPollFromNewObject() - { - var client = CreateFormTrainingClient(out var nonInstrumentedClient); - - await using var trainedModelA = await CreateDisposableTrainedModelAsync(useTrainingLabels: true); - await using var trainedModelB = await CreateDisposableTrainedModelAsync(useTrainingLabels: true); - - var operation = await client.StartCreateComposedModelAsync(new List { trainedModelA.ModelId, trainedModelB.ModelId }); - - var sameOperation = InstrumentOperation(new CreateComposedModelOperation(operation.Id, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(CustomFormModelStatus.Ready, sameOperation.Value.Status); - } - - [RecordedTest] - public async Task CopyModelOperationCanPollFromNewObject() - { - var client = CreateFormTrainingClient(out var nonInstrumentedClient); - var resourceId = TestEnvironment.ResourceId; - var region = TestEnvironment.ResourceRegion; - - await using var trainedModel = await CreateDisposableTrainedModelAsync(useTrainingLabels: false); - CopyAuthorization targetAuth = await client.GetCopyAuthorizationAsync(resourceId, region); - - var operation = await client.StartCopyModelAsync(trainedModel.ModelId, targetAuth); - - var sameOperation = InstrumentOperation(new CopyModelOperation(operation.Id, targetAuth.ModelId, nonInstrumentedClient)); - await sameOperation.WaitForCompletionAsync(); - - Assert.IsTrue(sameOperation.HasValue); - Assert.AreEqual(targetAuth.ModelId, sameOperation.Value.ModelId); - } - } -} diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/OperationsMockTests.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/OperationsMockTests.cs index 9c5b4883407c..4a5b9286998d 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/OperationsMockTests.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/FormRecognizerModels/OperationsMockTests.cs @@ -2,11 +2,15 @@ // Licensed under the MIT License. using System; +using System.Collections.Generic; using System.IO; +using System.Linq; using System.Text; +using System.Threading; using System.Threading.Tasks; using Azure.AI.FormRecognizer.Models; using Azure.AI.FormRecognizer.Training; +using Azure.Core; using Azure.Core.TestFramework; using Azure.Core.Tests; using NUnit.Framework; @@ -18,7 +22,11 @@ namespace Azure.AI.FormRecognizer.Tests.Models /// public class OperationsMockTests : ClientTestBase { - private string DiagnosticNamespace = "Azure.AI.FormRecognizer"; + private const string DiagnosticNamespace = "Azure.AI.FormRecognizer"; + + private const string PrebuiltOperationLocation = "https://fake.cognitiveservices.azure.com/formrecognizer/v2.1/layout/analyzeResults/abe0e5a4-1df1-4288-bfd9-334b5ad7cdb3"; + + private const string CustomOperationLocation = "https://fake.cognitiveservices.azure.com/formrecognizer/v2.1/custom/models/ceb5aaea-63cf-43f3-99d2-ea0fe1f234d1/analyzeresults/235deffa-cb8a-45d0-8405-df399237de8a"; /// /// Initializes a new instance of the class. @@ -29,34 +37,6 @@ public OperationsMockTests(bool isAsync) { } - /// - /// Creates a fake with the specified set of options. - /// - /// A set of options to apply when configuring the client. - /// The fake . - private FormRecognizerClient CreateFormRecognizerClient(FormRecognizerClientOptions options = default) - { - var fakeEndpoint = new Uri("http://localhost"); - var fakeCredential = new AzureKeyCredential("fakeKey"); - options ??= new FormRecognizerClientOptions(); - - return new FormRecognizerClient(fakeEndpoint, fakeCredential, options); - } - - /// - /// Creates a fake with the specified set of options. - /// - /// A set of options to apply when configuring the client. - /// The fake . - private FormTrainingClient CreateFormTrainingClient(FormRecognizerClientOptions options = default) - { - var fakeEndpoint = new Uri("http://localhost"); - var fakeCredential = new AzureKeyCredential("fakeKey"); - options ??= new FormRecognizerClientOptions(); - - return new FormTrainingClient(fakeEndpoint, fakeCredential, options); - } - [Test] public async Task RecognizeContentOperationCreatesDiagnosticScopeOnUpdate() { @@ -84,6 +64,32 @@ public async Task RecognizeContentOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(RecognizeContentOperation)}.{nameof(RecognizeContentOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeContentOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, PrebuiltOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeContentFromUriAsync(uri); + var sameOperation = new RecognizeContentOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeContentOperationRequiredParameters() { @@ -119,6 +125,32 @@ public async Task RecognizeReceiptsOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(RecognizeReceiptsOperation)}.{nameof(RecognizeReceiptsOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeReceiptsOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, PrebuiltOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeReceiptsFromUriAsync(uri); + var sameOperation = new RecognizeReceiptsOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeReceiptsOperationRequiredParameters() { @@ -154,6 +186,32 @@ public async Task RecognizeBusinessCardsOperationCreatesDiagnosticScopeOnUpdate( testListener.AssertScope($"{nameof(RecognizeBusinessCardsOperation)}.{nameof(RecognizeBusinessCardsOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeBusinessCardsOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, PrebuiltOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeBusinessCardsFromUriAsync(uri); + var sameOperation = new RecognizeBusinessCardsOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeBusinessCardsOperationRequiredParameters() { @@ -191,6 +249,32 @@ public async Task RecognizeInvoicesOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(RecognizeInvoicesOperation)}.{nameof(RecognizeInvoicesOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeInvoicesOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, PrebuiltOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeInvoicesFromUriAsync(uri); + var sameOperation = new RecognizeInvoicesOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeInvoicesOperationRequiredParameters() { @@ -228,6 +312,32 @@ public async Task RecognizeIdentityDocumentsOperationCreatesDiagnosticScopeOnUpd testListener.AssertScope($"{nameof(RecognizeIdentityDocumentsOperation)}.{nameof(RecognizeIdentityDocumentsOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeIdentityDocumentsOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, PrebuiltOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeIdentityDocumentsFromUriAsync(uri); + var sameOperation = new RecognizeIdentityDocumentsOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeIdentityDocumentsOperationRequiredParameters() { @@ -263,6 +373,32 @@ public async Task RecognizeCustomFormsOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(RecognizeCustomFormsOperation)}.{nameof(RecognizeCustomFormsOperation.UpdateStatus)}"); } + [Test] + public async Task RecognizeCustomFormsOperationCanPollFromNewObject() + { + using var emptyResponseBody0 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var emptyResponseBody1 = new MemoryStream(Encoding.UTF8.GetBytes("{}")); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = emptyResponseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = emptyResponseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, CustomOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormRecognizerClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartRecognizeCustomFormsFromUriAsync(Guid.NewGuid().ToString(), uri); + var sameOperation = new RecognizeCustomFormsOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void RecognizeCustomFormsOperationRequiredParameters() { @@ -280,8 +416,7 @@ public async Task TrainingOperationCreatesDiagnosticScopeOnUpdate() using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@" { ""modelInfo"": { - ""status"": ""creating"", - ""modelId"": ""00000000-0000-0000-0000-000000000000"" + ""status"": ""creating"" } }")); @@ -306,6 +441,39 @@ public async Task TrainingOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(CreateCustomFormModelOperation)}.{nameof(CreateCustomFormModelOperation.UpdateStatus)}"); } + [Test] + public async Task TrainingOperationCanPollFromNewObject() + { + string jsonResponse = """ + { + "modelInfo": { + "status": "creating" + } + } + """; + using var responseBody0 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var responseBody1 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var postResponse = new MockResponse(201); + using var getResponse0 = new MockResponse(200) { ContentStream = responseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = responseBody1 }; + + postResponse.AddHeader(new HttpHeader("Location", CustomOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormTrainingClient(options); + + var uri = FormRecognizerTestEnvironment.CreateUri(TestFile.Blank); + var operation = await client.StartTrainingAsync(uri, false); + var sameOperation = new TrainingOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void TrainingOperationRequiredParameters() { @@ -321,8 +489,7 @@ public async Task CreateComposedModelOperationCreatesDiagnosticScopeOnUpdate() using var stream = new MemoryStream(Encoding.UTF8.GetBytes(@" { ""modelInfo"": { - ""status"": ""creating"", - ""modelId"": ""00000000-0000-0000-0000-000000000000"" + ""status"": ""creating"" } }")); @@ -347,6 +514,39 @@ public async Task CreateComposedModelOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(CreateCustomFormModelOperation)}.{nameof(CreateCustomFormModelOperation.UpdateStatus)}"); } + [Test] + public async Task CreateComposedModelOperationCanPollFromNewObject() + { + string jsonResponse = """ + { + "modelInfo": { + "status": "creating" + } + } + """; + using var responseBody0 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var responseBody1 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var postResponse = new MockResponse(201); + using var getResponse0 = new MockResponse(200) { ContentStream = responseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = responseBody1 }; + + postResponse.AddHeader(new HttpHeader("Location", CustomOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormTrainingClient(options); + + var modelIds = new List() { Guid.NewGuid().ToString() }; + var operation = await client.StartCreateComposedModelAsync(modelIds); + var sameOperation = new CreateComposedModelOperation(operation.Id, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void CreateComposedModelOperationRequiredParameters() { @@ -382,6 +582,39 @@ public async Task CopyModelOperationCreatesDiagnosticScopeOnUpdate() testListener.AssertScope($"{nameof(CopyModelOperation)}.{nameof(CopyModelOperation.UpdateStatus)}"); } + [Test] + public async Task CopyModelOperationCanPollFromNewObject() + { + string jsonResponse = """ + { + "modelInfo": { + "status": "creating" + } + } + """; + using var responseBody0 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var responseBody1 = new MemoryStream(Encoding.UTF8.GetBytes(jsonResponse)); + using var postResponse = new MockResponse(202); + using var getResponse0 = new MockResponse(200) { ContentStream = responseBody0 }; + using var getResponse1 = new MockResponse(200) { ContentStream = responseBody1 }; + + postResponse.AddHeader(new HttpHeader(Constants.OperationLocationHeader, CustomOperationLocation)); + + var mockTransport = new MockTransport(new[] { postResponse, getResponse0, getResponse1 }); + var options = new FormRecognizerClientOptions() { Transport = mockTransport }; + var client = CreateFormTrainingClient(options); + + var targetAuth = new CopyAuthorization(Guid.NewGuid().ToString(), string.Empty, 0, string.Empty, string.Empty); + var operation = await client.StartCopyModelAsync(Guid.NewGuid().ToString(), targetAuth); + var sameOperation = new CopyModelOperation(operation.Id, targetAuth.ModelId, client); + + await operation.UpdateStatusAsync(); + await sameOperation.UpdateStatusAsync(); + + Assert.AreEqual(3, mockTransport.Requests.Count); + AssertRequestsAreEqual(mockTransport.Requests[1], mockTransport.Requests[2]); + } + [Test] public void CopyModelOperationRequiredParameters() { @@ -393,5 +626,62 @@ public void CopyModelOperationRequiredParameters() Assert.Throws(() => new CopyModelOperation(string.Empty, targetId, client)); Assert.Throws(() => new CopyModelOperation(operationId, targetId, null)); } + + /// + /// Creates a fake with the specified set of options. + /// + /// A set of options to apply when configuring the client. + /// The fake . + private FormRecognizerClient CreateFormRecognizerClient(FormRecognizerClientOptions options = default) + { + var fakeEndpoint = new Uri("http://localhost"); + var fakeCredential = new AzureKeyCredential("fakeKey"); + options ??= new FormRecognizerClientOptions(); + + return new FormRecognizerClient(fakeEndpoint, fakeCredential, options); + } + + /// + /// Creates a fake with the specified set of options. + /// + /// A set of options to apply when configuring the client. + /// The fake . + private FormTrainingClient CreateFormTrainingClient(FormRecognizerClientOptions options = default) + { + var fakeEndpoint = new Uri("http://localhost"); + var fakeCredential = new AzureKeyCredential("fakeKey"); + options ??= new FormRecognizerClientOptions(); + + return new FormTrainingClient(fakeEndpoint, fakeCredential, options); + } + + private static string GetString(RequestContent content) + { + if (content == null) + { + return null; + } + + using var stream = new MemoryStream(); + content.WriteTo(stream, CancellationToken.None); + + return Encoding.UTF8.GetString(stream.ToArray()); + } + + private void AssertRequestsAreEqual(MockRequest left, MockRequest right) + { + Assert.AreEqual(left.Uri.ToString(), right.Uri.ToString()); + Assert.AreEqual(left.Method, right.Method); + Assert.AreEqual(GetString(left.Content), GetString(right.Content)); + + var leftHeaders = left.Headers.ToDictionary(h => h.Name, h => h.Value); + var rightHeaders = right.Headers.ToDictionary(h => h.Name, h => h.Value); + + // Removing header excepted to be different for each request. + leftHeaders.Remove("x-ms-client-request-id"); + rightHeaders.Remove("x-ms-client-request-id"); + + CollectionAssert.AreEquivalent(leftHeaders, rightHeaders); + } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/DocumentAnalysisLiveTestBase.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/DocumentAnalysisLiveTestBase.cs index 212f7db00c86..60afaac6412e 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/DocumentAnalysisLiveTestBase.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/DocumentAnalysisLiveTestBase.cs @@ -127,8 +127,6 @@ protected async Task BuildDisposableDocumentModelAsync( ContainerType.Singleforms => TestEnvironment.BlobContainerSasUrl, ContainerType.MultipageFiles => TestEnvironment.MultipageBlobContainerSasUrl, ContainerType.SelectionMarks => TestEnvironment.SelectionMarkBlobContainerSasUrl, - ContainerType.TableVariableRows => TestEnvironment.TableDynamicRowsContainerSasUrl, - ContainerType.TableFixedRows => TestEnvironment.TableFixedRowsContainerSasUrl, _ => TestEnvironment.BlobContainerSasUrl, }; var trainingFilesUri = new Uri(trainingFiles); @@ -169,9 +167,7 @@ protected enum ContainerType { Singleforms, MultipageFiles, - SelectionMarks, - TableVariableRows, - TableFixedRows + SelectionMarks } } } diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/FormRecognizerLiveTestBase.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/FormRecognizerLiveTestBase.cs index 53b3bc24c303..10c01ba47030 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/FormRecognizerLiveTestBase.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/Infrastructure/FormRecognizerLiveTestBase.cs @@ -119,8 +119,6 @@ protected async Task CreateDisposableTrainedModelAsync(b ContainerType.Singleforms => TestEnvironment.BlobContainerSasUrl, ContainerType.MultipageFiles => TestEnvironment.MultipageBlobContainerSasUrl, ContainerType.SelectionMarks => TestEnvironment.SelectionMarkBlobContainerSasUrl, - ContainerType.TableVariableRows => TestEnvironment.TableDynamicRowsContainerSasUrl, - ContainerType.TableFixedRows => TestEnvironment.TableFixedRowsContainerSasUrl, _ => TestEnvironment.BlobContainerSasUrl, }; var trainingFilesUri = new Uri(trainingFiles); @@ -132,9 +130,7 @@ protected enum ContainerType { Singleforms, MultipageFiles, - SelectionMarks, - TableVariableRows, - TableFixedRows + SelectionMarks } protected void ValidatePrebuiltForm(RecognizedForm recognizedForm, bool includeFieldElements, int expectedFirstPageNumber, int expectedLastPageNumber) diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/DocumentAnalysisSamples.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/DocumentAnalysisSamples.cs index 91c246750d11..7a1a235e6c74 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/DocumentAnalysisSamples.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/DocumentAnalysisSamples.cs @@ -7,6 +7,7 @@ namespace Azure.AI.FormRecognizer.DocumentAnalysis.Samples { [LiveOnly] + [AsyncOnly] // Ensure that each sample will only run once. [IgnoreServiceError(400, "InvalidRequest", Message = "Content is not accessible: Invalid data URL", Reason = "https://github.com/Azure/azure-sdk-for-net/issues/28923")] public partial class DocumentAnalysisSamples : RecordedTestBase { diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/Sample_ManageModels.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/Sample_ManageModels.cs index 5763b81c5757..ebe45036c365 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/Sample_ManageModels.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/Sample_ManageModels.cs @@ -3,8 +3,6 @@ using System; using System.Linq; -using System.Threading.Tasks; -using Azure.AI.FormRecognizer.DocumentAnalysis.Tests; using Azure.Core.TestFramework; namespace Azure.AI.FormRecognizer.DocumentAnalysis.Samples diff --git a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/V3.1/FormRecognizerSamples.cs b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/V3.1/FormRecognizerSamples.cs index e0ec42a404d4..1f9af7f3f9c9 100644 --- a/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/V3.1/FormRecognizerSamples.cs +++ b/sdk/formrecognizer/Azure.AI.FormRecognizer/tests/samples/V3.1/FormRecognizerSamples.cs @@ -7,6 +7,7 @@ namespace Azure.AI.FormRecognizer.Samples { [LiveOnly] + [AsyncOnly] // Ensure that each sample will only run once. [IgnoreServiceError(200, "3014", Message = "Generic error during training.", Reason = "https://github.com/Azure/azure-sdk-for-net/issues/28913")] public partial class FormRecognizerSamples : RecordedTestBase { diff --git a/sdk/formrecognizer/assets.json b/sdk/formrecognizer/assets.json index 38105060c892..c964c7b12b21 100644 --- a/sdk/formrecognizer/assets.json +++ b/sdk/formrecognizer/assets.json @@ -2,5 +2,5 @@ "AssetsRepo": "Azure/azure-sdk-assets", "AssetsRepoPrefixPath": "net", "TagPrefix": "net/formrecognizer", - "Tag": "net/formrecognizer_2475157f2c" + "Tag": "net/formrecognizer_1c6d519fcc" }