[Tests] Move to NUnit 4 patterns in preparation for upgrade to NUnit and unbranded test framework

tests/Assistants/Assistants.VectorStoresTests.cs

@@ -328,14 +328,14 @@ public async Task Pagination_CanRehydrateFileAssociationCollectionAsync()
             List<VectorStoreFileAssociation> itemsInPage = GetFileAssociationsFromPage(page).ToList();
             List<VectorStoreFileAssociation> itemsInRehydratedPage = GetFileAssociationsFromPage(rehydratedPage).ToList();
 
-            Assert.AreEqual(itemsInPage.Count, itemsInRehydratedPage.Count);
+            Assert.That(itemsInRehydratedPage.Count, Is.EqualTo(itemsInPage.Count));
 
             for (int i = 0; i < itemsInPage.Count; i++)
             {
-                Assert.AreEqual(itemsInPage[0].FileId, itemsInRehydratedPage[0].FileId);
-                Assert.AreEqual(itemsInPage[0].VectorStoreId, itemsInRehydratedPage[0].VectorStoreId);
-                Assert.AreEqual(itemsInPage[0].CreatedAt, itemsInRehydratedPage[0].CreatedAt);
-                Assert.AreEqual(itemsInPage[0].Size, itemsInRehydratedPage[0].Size);
+                Assert.That(itemsInRehydratedPage[0].FileId, Is.EqualTo(itemsInPage[0].FileId));
+                Assert.That(itemsInRehydratedPage[0].VectorStoreId, Is.EqualTo(itemsInPage[0].VectorStoreId));
+                Assert.That(itemsInRehydratedPage[0].CreatedAt, Is.EqualTo(itemsInPage[0].CreatedAt));
+                Assert.That(itemsInRehydratedPage[0].Size, Is.EqualTo(itemsInPage[0].Size));
             }
 
             pageCount++;
@@ -406,14 +406,14 @@ public void Pagination_CanRehydrateFileAssociationCollection()
             List<VectorStoreFileAssociation> itemsInPage = GetFileAssociationsFromPage(page).ToList();
             List<VectorStoreFileAssociation> itemsInRehydratedPage = GetFileAssociationsFromPage(rehydratedPage).ToList();
 
-            Assert.AreEqual(itemsInPage.Count, itemsInRehydratedPage.Count);
+            Assert.That(itemsInRehydratedPage.Count, Is.EqualTo(itemsInPage.Count));
 
             for (int i = 0; i < itemsInPage.Count; i++)
             {
-                Assert.AreEqual(itemsInPage[0].FileId, itemsInRehydratedPage[0].FileId);
-                Assert.AreEqual(itemsInPage[0].VectorStoreId, itemsInRehydratedPage[0].VectorStoreId);
-                Assert.AreEqual(itemsInPage[0].CreatedAt, itemsInRehydratedPage[0].CreatedAt);
-                Assert.AreEqual(itemsInPage[0].Size, itemsInRehydratedPage[0].Size);
+                Assert.That(itemsInRehydratedPage[0].FileId, Is.EqualTo(itemsInPage[0].FileId));
+                Assert.That(itemsInRehydratedPage[0].VectorStoreId, Is.EqualTo(itemsInPage[0].VectorStoreId));
+                Assert.That(itemsInRehydratedPage[0].CreatedAt, Is.EqualTo(itemsInPage[0].CreatedAt));
+                Assert.That(itemsInRehydratedPage[0].Size, Is.EqualTo(itemsInPage[0].Size));
             }
 
             pageCount++;
@@ -523,7 +523,7 @@ public void CanRehydrateBatchFileJob()
 
         Assert.IsTrue(batchOperation.HasCompleted);
         Assert.IsTrue(rehydratedOperation.HasCompleted);
-        Assert.AreEqual(batchOperation.Status, rehydratedOperation.Status);
+        Assert.That(rehydratedOperation.Status, Is.EqualTo(batchOperation.Status));
     }
 
     public enum ChunkingStrategyKind { Auto, Static }

tests/Assistants/AssistantsSmokeTests.cs

@@ -79,7 +79,7 @@ public void ResponseFormatEquality()
         Assert.That((AssistantResponseFormat)null != AssistantResponseFormat.CreateTextFormat());
         Assert.That(AssistantResponseFormat.CreateTextFormat() != null);
         Assert.That(AssistantResponseFormat.CreateTextFormat(), Is.Not.EqualTo(null));
-        Assert.That(null, Is.Not.EqualTo(AssistantResponseFormat.CreateTextFormat()));
+        Assert.That(AssistantResponseFormat.CreateTextFormat(), Is.Not.Null);
 
         AssistantResponseFormat jsonSchemaFormat = AssistantResponseFormat.CreateJsonSchemaFormat(
             name: "test_schema",

tests/Assistants/AssistantsTests.cs

@@ -1760,7 +1760,7 @@ public async Task Pagination_CanCastAssistantPageCollectionToConvenienceFromProt
         // functions correctly as the convenience return type.
         await foreach (Assistant assistant in assistants)
         {
-            Assert.AreEqual(createdAssistants[count++].Id, assistant.Id);
+            Assert.That(assistant.Id, Is.EqualTo(createdAssistants[count++].Id));
 
             if (count >= createdAssistants.Count)
             {
@@ -1810,7 +1810,7 @@ public void Pagination_CanCastAssistantPageCollectionToConvenienceFromProtocol()
         // functions correctly as the convenience return type.
         foreach (Assistant assistant in assistants)
         {
-            Assert.AreEqual(createdAssistants[count++].Id, assistant.Id);
+            Assert.That(assistant.Id, Is.EqualTo(createdAssistants[count++].Id));
 
             if (count >= createdAssistants.Count)
             {
@@ -1893,7 +1893,7 @@ public async Task Pagination_CanRehydrateRunStepPageCollectionFromBytesAsync()
                 .ToListAsync();
         }
 
-        CollectionAssert.AreEqual(runSteps, rehydratedRunSteps);
+        Assert.That(rehydratedRunSteps, Is.EqualTo(runSteps).AsCollection);
     }
 
     [Test]
@@ -1967,7 +1967,7 @@ public void Pagination_CanRehydrateRunStepPageCollectionFromBytes()
                 .ToList();
         }
 
-        CollectionAssert.AreEqual(runSteps, rehydratedRunSteps);
+        Assert.That(rehydratedRunSteps, Is.EqualTo(runSteps).AsCollection);
     }
 
     [Test]

tests/Audio/TranscriptionTests.cs

@@ -180,7 +180,6 @@ public async Task TranscriptionFormatsWork(string responseFormat)
 
                 Assert.That(segment.Id, Is.EqualTo(i));
                 Assert.That(segment.EndTime, Is.GreaterThanOrEqualTo(segment.StartTime));
-                Assert.That(segment.TokenIds, Is.Not.Null);
                 Assert.That(segment.TokenIds.Length, Is.GreaterThan(0));
 
                 Assert.That(segment.AverageLogProbability, Is.LessThan(-0.001f).Or.GreaterThan(0.001f));

tests/Batch/BatchTests.cs

@@ -233,13 +233,13 @@ static bool Validate(CreateBatchOperation operation)
         // We don't test wait for completion live because this is documented to
         // sometimes take 24 hours.
 
-        Assert.AreEqual(batchOperation.HasCompleted, rehydratedOperation.HasCompleted);
+        Assert.That(rehydratedOperation.HasCompleted, Is.EqualTo(batchOperation.HasCompleted));
 
         using JsonDocument originalOperationJson = JsonDocument.Parse(batchOperation.GetRawResponse().Content);
         using JsonDocument rehydratedOperationJson = JsonDocument.Parse(rehydratedOperation.GetRawResponse().Content);
 
-        Assert.AreEqual(originalOperationJson.RootElement.GetProperty("id").GetString(), rehydratedOperationJson.RootElement.GetProperty("id").GetString());
-        Assert.AreEqual(originalOperationJson.RootElement.GetProperty("created_at").GetInt64(), rehydratedOperationJson.RootElement.GetProperty("created_at").GetInt64());
-        Assert.AreEqual(originalOperationJson.RootElement.GetProperty("status").GetString(), rehydratedOperationJson.RootElement.GetProperty("status").GetString());
+        Assert.That(rehydratedOperationJson.RootElement.GetProperty("id").GetString(), Is.EqualTo(originalOperationJson.RootElement.GetProperty("id").GetString()));
+        Assert.That(rehydratedOperationJson.RootElement.GetProperty("created_at").GetInt64(), Is.EqualTo(originalOperationJson.RootElement.GetProperty("created_at").GetInt64()));
+        Assert.That(rehydratedOperationJson.RootElement.GetProperty("status").GetString(), Is.EqualTo(originalOperationJson.RootElement.GetProperty("status").GetString()));
     }
 }

tests/Chat/ChatStoreTests.cs

@@ -672,7 +672,7 @@ await RetryWithExponentialBackoffAsync(async () =>
             {
                 messageCount++;
                 Assert.That(message.Id, Is.Not.Null.And.Not.Empty);
-                Assert.AreEqual("Basic messages test: Say 'Hello, this is a test message.'", message.Content);
+                Assert.That(message.Content, Is.EqualTo("Basic messages test: Say 'Hello, this is a test message.'"));
 
                 if (messageCount >= 5) break; // Prevent infinite loop
             }

tests/Chat/ChatTests.cs

@@ -903,24 +903,24 @@ public async Task HelloWorldChatWithTracingAndMetrics()
             ? await client.CompleteChatAsync(messages)
             : client.CompleteChat(messages);
 
-        Assert.AreEqual(1, activityListener.Activities.Count);
+        Assert.That(activityListener.Activities.Count, Is.EqualTo(1));
         TestActivityListener.ValidateChatActivity(activityListener.Activities.Single(), result.Value);
 
         List<TestMeasurement> durations = meterListener.GetMeasurements("gen_ai.client.operation.duration");
-        Assert.AreEqual(1, durations.Count);
+        Assert.That(durations.Count, Is.EqualTo(1));
         ValidateChatMetricTags(durations.Single(), result.Value);
 
         List<TestMeasurement> usages = meterListener.GetMeasurements("gen_ai.client.token.usage");
-        Assert.AreEqual(2, usages.Count);
+        Assert.That(usages.Count, Is.EqualTo(2));
 
         Assert.True(usages[0].tags.TryGetValue("gen_ai.token.type", out var type));
         Assert.IsInstanceOf<string>(type);
 
         TestMeasurement input = (type is "input") ? usages[0] : usages[1];
         TestMeasurement output = (type is "input") ? usages[1] : usages[0];
 
-        Assert.AreEqual(result.Value.Usage.InputTokenCount, input.value);
-        Assert.AreEqual(result.Value.Usage.OutputTokenCount, output.value);
+        Assert.That(input.value, Is.EqualTo(result.Value.Usage.InputTokenCount));
+        Assert.That(output.value, Is.EqualTo(result.Value.Usage.OutputTokenCount));
     }
 
     [Test]

tests/FineTuning/FineTuningClientTests.cs

@@ -78,7 +78,7 @@ public async Task MinimalRequiredParams([Values(Method.Sync, Method.Async)] Meth
             ? await ft.CancelAndUpdateAsync()
             : ft.CancelAndUpdate();
 
-        Assert.AreEqual(FineTuningStatus.Cancelled, ft.Status);
+        Assert.That(ft.Status, Is.EqualTo(FineTuningStatus.Cancelled));
         Assert.False(ft.Status.InProgress);
         Assert.True(ft.HasCompleted);
     }
@@ -110,25 +110,25 @@ public async Task AllParameters([Values(Method.Sync, Method.Async)] Method metho
         ft.CancelAndUpdate();
 
 #pragma warning disable CS0618
-        Assert.AreEqual(1, ft.Hyperparameters.EpochCount);
-        Assert.AreEqual(2, ft.Hyperparameters.BatchSize);
-        Assert.AreEqual(3, ft.Hyperparameters.LearningRateMultiplier);
+        Assert.That(ft.Hyperparameters.EpochCount, Is.EqualTo(1));
+        Assert.That(ft.Hyperparameters.BatchSize, Is.EqualTo(2));
+        Assert.That(ft.Hyperparameters.LearningRateMultiplier, Is.EqualTo(3));
 #pragma warning restore
 
         if (ft.MethodHyperparameters is HyperparametersForSupervised hp)
         {
-            Assert.AreEqual(1, hp.EpochCount);
-            Assert.AreEqual(2, hp.BatchSize);
-            Assert.AreEqual(3, hp.LearningRateMultiplier);
+            Assert.That(hp.EpochCount, Is.EqualTo(1));
+            Assert.That(hp.BatchSize, Is.EqualTo(2));
+            Assert.That(hp.LearningRateMultiplier, Is.EqualTo(3));
         }
         else
         {
             Assert.Fail($"Expected HyperparametersForSupervised, got {ft.MethodHyperparameters?.GetType().ToString() ?? "null"}");
         }
 
-        Assert.AreEqual(ft.UserProvidedSuffix, "TestFTJob");
-        Assert.AreEqual(1234567, ft.Seed);
-        Assert.AreEqual(validationFile.Id, ft.ValidationFileId);
+        Assert.That(ft.UserProvidedSuffix, Is.EqualTo("TestFTJob"));
+        Assert.That(ft.Seed, Is.EqualTo(1234567));
+        Assert.That(ft.ValidationFileId, Is.EqualTo(validationFile.Id));
     }
 
     [Test]
@@ -233,7 +233,7 @@ public void GetJobsWithAfter()
         }
         var secondJob = client.GetJobs(new() { AfterJobId = firstJob.JobId }).First();
 
-        Assert.AreNotEqual(firstJob.JobId, secondJob.JobId);
+        Assert.That(secondJob.JobId, Is.Not.EqualTo(firstJob.JobId));
         // Can't assert that one was created after the next because they might be created at the same second.
         // Assert.Greater(secondJob.CreatedAt, firstJob.CreatedAt, $"{firstJob}, {secondJob}");
     }

tests/FineTuning/HyperparameterOptionsTests.cs

@@ -13,20 +13,20 @@ class HyperparameterOptionsTests
     [Parallelizable]
     public void OptionsCanEasilyCompare()
     {
-        Assert.AreEqual(HyperparameterEpochCount.CreateAuto(), "auto");
-        Assert.AreEqual(HyperparameterBatchSize.CreateAuto(), "auto");
-        Assert.AreEqual(HyperparameterLearningRate.CreateAuto(), "auto");
-        Assert.AreEqual(HyperparameterBetaFactor.CreateAuto(), "auto");
+        Assert.That(HyperparameterEpochCount.CreateAuto(), Is.EqualTo("auto"));
+        Assert.That(HyperparameterBatchSize.CreateAuto(), Is.EqualTo("auto"));
+        Assert.That(HyperparameterLearningRate.CreateAuto(), Is.EqualTo("auto"));
+        Assert.That(HyperparameterBetaFactor.CreateAuto(), Is.EqualTo("auto"));
 
-        Assert.AreEqual(new HyperparameterEpochCount(1), 1);
-        Assert.AreEqual(new HyperparameterBatchSize(1), 1);
-        Assert.AreEqual(new HyperparameterLearningRate(1), 1);
-        Assert.AreEqual(new HyperparameterBetaFactor(1), 1);
+        Assert.That(new HyperparameterEpochCount(1), Is.EqualTo(1));
+        Assert.That(new HyperparameterBatchSize(1), Is.EqualTo(1));
+        Assert.That(new HyperparameterLearningRate(1), Is.EqualTo(1));
+        Assert.That(new HyperparameterBetaFactor(1), Is.EqualTo(1));
 
-        Assert.AreEqual(1, new HyperparameterEpochCount(1));
-        Assert.AreEqual(1, new HyperparameterBatchSize(1));
-        Assert.AreEqual(1.0, new HyperparameterLearningRate(1));
-        Assert.AreEqual(1, new HyperparameterBetaFactor(1));
+        Assert.That(new HyperparameterEpochCount(1), Is.EqualTo(1));
+        Assert.That(new HyperparameterBatchSize(1), Is.EqualTo(1));
+        Assert.That(new HyperparameterLearningRate(1), Is.EqualTo(1.0));
+        Assert.That(new HyperparameterBetaFactor(1), Is.EqualTo(1));
 
         Assert.That(1 == new HyperparameterEpochCount(1));
         Assert.That(1 == new HyperparameterBatchSize(1));

tests/Telemetry/ChatTelemetryTests.cs

@@ -121,7 +121,7 @@ public void TracingOnMetricsOff()
         }
 
         Assert.Null(Activity.Current);
-        Assert.AreEqual(1, listener.Activities.Count);
+        Assert.That(listener.Activities.Count, Is.EqualTo(1));
 
         ValidateChatActivity(listener.Activities.Single(), chatCompletion, RequestModel, Host, Port);
     }
@@ -144,9 +144,9 @@ public void ChatTracingAllAttributes()
 
         using (var scope = telemetry.StartChatScope(options))
         {
-            Assert.AreEqual(options.Temperature.Value, (float)Activity.Current.GetTagItem("gen_ai.request.temperature"), 0.01);
-            Assert.AreEqual(options.TopP.Value, (float)Activity.Current.GetTagItem("gen_ai.request.top_p"), 0.01);
-            Assert.AreEqual(options.MaxOutputTokenCount.Value, Activity.Current.GetTagItem("gen_ai.request.max_tokens"));
+            Assert.That((float)Activity.Current.GetTagItem("gen_ai.request.temperature"), Is.EqualTo(options.Temperature.Value).Within(0.01));
+            Assert.That((float)Activity.Current.GetTagItem("gen_ai.request.top_p"), Is.EqualTo(options.TopP.Value).Within(0.01));
+            Assert.That(Activity.Current.GetTagItem("gen_ai.request.max_tokens"), Is.EqualTo(options.MaxOutputTokenCount.Value));
             scope.RecordChatCompletion(chatCompletion);
         }
         Assert.Null(Activity.Current);
@@ -215,23 +215,23 @@ public async Task ChatTracingAndMetricsMultiple()
 
         await Task.WhenAll(tasks);
 
-        Assert.AreEqual(tasks.Length, activityListener.Activities.Count);
+        Assert.That(activityListener.Activities.Count, Is.EqualTo(tasks.Length));
 
         var durations = meterListener.GetMeasurements("gen_ai.client.operation.duration");
-        Assert.AreEqual(tasks.Length, durations.Count);
-        Assert.AreEqual(numberOfSuccessfulResponses, durations.Count(d => !d.tags.ContainsKey("error.type")));
+        Assert.That(durations.Count, Is.EqualTo(tasks.Length));
+        Assert.That(durations.Count(d => !d.tags.ContainsKey("error.type")), Is.EqualTo(numberOfSuccessfulResponses));
 
         var usages = meterListener.GetMeasurements("gen_ai.client.token.usage");
         // we don't report usage if there was no response
-        Assert.AreEqual(numberOfSuccessfulResponses * 2, usages.Count);
+        Assert.That(usages.Count, Is.EqualTo(numberOfSuccessfulResponses * 2));
         Assert.IsEmpty(usages.Where(u => u.tags.ContainsKey("error.type")));
 
-        Assert.AreEqual(totalPromptTokens, usages
+        Assert.That(usages
             .Where(u => u.tags.Contains(new KeyValuePair<string, object>("gen_ai.token.type", "input")))
-            .Sum(u => (long)u.value));
-        Assert.AreEqual(totalCompletionTokens, usages
+            .Sum(u => (long)u.value), Is.EqualTo(totalPromptTokens));
+        Assert.That(usages
             .Where(u => u.tags.Contains(new KeyValuePair<string, object>("gen_ai.token.type", "output")))
-            .Sum(u => (long)u.value));
+            .Sum(u => (long)u.value), Is.EqualTo(totalCompletionTokens));
     }
 
     private void SetMessages(ChatCompletionOptions options, params ChatMessage[] messages)
@@ -248,7 +248,7 @@ private void ValidateDuration(TestMeterListener listener, ChatCompletion respons
 
         var measurements = listener.GetMeasurements("gen_ai.client.operation.duration");
         Assert.IsNotNull(measurements);
-        Assert.AreEqual(1, measurements.Count);
+        Assert.That(measurements.Count, Is.EqualTo(1));
 
         var measurement = measurements[0];
         Assert.IsInstanceOf<double>(measurement.value);
@@ -266,7 +266,7 @@ private void ValidateUsage(TestMeterListener listener, ChatCompletion response,
 
         var measurements = listener.GetMeasurements("gen_ai.client.token.usage");
         Assert.IsNotNull(measurements);
-        Assert.AreEqual(2, measurements.Count);
+        Assert.That(measurements.Count, Is.EqualTo(2));
 
         foreach (var measurement in measurements)
         {
@@ -280,8 +280,8 @@ private void ValidateUsage(TestMeterListener listener, ChatCompletion response,
         TestMeasurement input = (type is "input") ? measurements[0] : measurements[1];
         TestMeasurement output = (type is "input") ? measurements[1] : measurements[0];
 
-        Assert.AreEqual(inputTokens, input.value);
-        Assert.AreEqual(outputTokens, output.value);
+        Assert.That(input.value, Is.EqualTo(inputTokens));
+        Assert.That(output.value, Is.EqualTo(outputTokens));
     }
 
     private static ChatCompletion CreateChatCompletion(int promptTokens = PromptTokens, int completionTokens = CompletionTokens)