From 4205cd3a7932ca9dab91eda2d2e8a7cf5d0ad1f0 Mon Sep 17 00:00:00 2001 From: Dmytro Struk <13853051+dmytrostruk@users.noreply.github.com> Date: Wed, 17 Jan 2024 12:04:30 +0000 Subject: [PATCH] .Net: Increase code coverage and add threshold to build pipeline (#4610) ### Motivation and Context Resolves: https://github.com/microsoft/semantic-kernel/issues/4372 Added more tests and increased code coverage for production packages to meet 80% threshold. Added new steps to PR build pipeline to check code coverage for production packages and trigger a failure if code coverage in PR is lower than defined threshold. Example of code coverage output: ![image](https://github.com/microsoft/semantic-kernel/assets/13853051/2a271dcf-5e87-4006-a3b1-5bcfce829f3a) ### Contribution Checklist - [x] The code builds clean without any errors or warnings - [x] The PR follows the [SK Contribution Guidelines](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md) and the [pre-submission formatting script](https://github.com/microsoft/semantic-kernel/blob/main/CONTRIBUTING.md#development-scripts) raises no violations - [x] All unit tests pass, and I have added new tests where possible - [x] I didn't break anyone :smile: --- .github/workflows/check-coverage.ps1 | 54 ++ .github/workflows/dotnet-build-and-test.yml | 19 +- dotnet/SK-dotnet.sln | 6 + dotnet/code-coverage.ps1 | 60 ++ .../AzureSdk/AzureOpenAIClientCore.cs | 13 - .../AzureOpenAIWithDataChatMessageContent.cs | 3 +- ...ureOpenAITextEmbeddingGenerationService.cs | 1 - .../TextToImage/OpenAITextToImageService.cs | 6 +- .../Connectors.UnitTests.csproj | 17 +- .../MultipleHttpMessageHandlerStub.cs | 53 ++ ...reOpenAIWithDataChatMessageContentTests.cs | 70 +++ ...ithDataStreamingChatMessageContentTests.cs | 59 ++ .../AzureSdk/OpenAIChatMessageContentTests.cs | 104 ++++ .../AzureSdk/OpenAIFunctionToolCallTests.cs | 81 +++ .../OpenAIPluginCollectionExtensionsTests.cs | 74 +++ .../OpenAIStreamingTextContentTests.cs | 42 ++ .../RequestFailedExceptionExtensionsTests.cs | 79 +++ .../AzureOpenAIChatCompletionServiceTests.cs | 583 ++++++++++++++++++ ...cs => OpenAIChatCompletionServiceTests.cs} | 80 ++- .../AzureOpenAIChatCompletionWithDataTests.cs | 118 +++- .../FunctionCalling/OpenAIFunctionTests.cs | 45 ++ .../OpenAIMemoryBuilderExtensionsTests.cs | 66 ++ .../OpenAIPromptExecutionSettingsTests.cs | 12 + .../OpenAIServiceCollectionExtensionsTests.cs | 497 +++++++++++++++ ...multiple_function_calls_test_response.json | 56 ++ ...on_single_function_call_test_response.json | 32 + ..._multiple_function_calls_test_response.txt | 9 + ...ing_single_function_call_test_response.txt | 3 + ...hat_completion_streaming_test_response.txt | 3 + .../chat_completion_test_response.json | 22 + ...tion_with_data_streaming_test_response.txt | 1 + ...at_completion_with_data_test_response.json | 28 + .../image_generation_test_response.json | 4 - .../TestData/image_result_test_response.json | 12 - ...ext_completion_streaming_test_response.txt | 3 + .../text_completion_test_response.json | 19 + ...enAITextEmbeddingGenerationServiceTests.cs | 152 +++++ ...enAITextEmbeddingGenerationServiceTests.cs | 135 ++++ .../AzureOpenAITextGenerationServiceTests.cs | 208 +++++++ .../OpenAITextGenerationServiceTests.cs | 113 ++++ .../OpenAITextToImageServiceTests.cs | 85 +++ .../OpenAI/ToolCallBehaviorTests.cs | 218 +++++++ .../HandlebarsPromptTemplateTests.cs | 34 +- .../Helpers/KernelFunctionHelpersTests.cs | 95 +++ .../Helpers/KernelHelperUtilsTests.cs | 38 ++ .../Helpers/KernelSystemHelpersTests.cs | 84 ++- .../KernelHelpers/KernelSystemHelpers.cs | 22 +- .../OpenApi/RestApiOperationResponseTests.cs | 15 + .../Diagnostics/CompilerServicesAttributes.cs | 3 + .../src/Diagnostics/ExceptionExtensions.cs | 2 + .../src/Diagnostics/ExperimentalAttribute.cs | 1 + .../src/Diagnostics/NullableAttributes.cs | 6 + .../src/Diagnostics/Verify.cs | 1 + .../src/Http/HttpClientExtensions.cs | 2 + .../src/Http/HttpClientProvider.cs | 2 + .../src/Http/HttpContentExtensions.cs | 2 + .../src/Http/HttpHeaderValues.cs | 3 + .../InternalUtilities/src/Http/HttpRequest.cs | 2 + .../src/Linq/AsyncEnumerable.cs | 2 + .../src/System/EnvExtensions.cs | 3 + .../src/System/InternalTypeConverter.cs | 2 + .../src/System/TypeConverterFactory.cs | 2 + .../src/Text/JsonOptionsCache.cs | 2 + .../src/Text/ReadOnlyMemoryConverter.cs | 2 + .../src/Type/TypeExtensions.cs | 2 + .../Plugins.UnitTests.csproj | 4 + .../Contents/ImageContentTests.cs | 29 + .../Utilities/TypeExtensionsTests.cs | 37 ++ 68 files changed, 3557 insertions(+), 85 deletions(-) create mode 100644 .github/workflows/check-coverage.ps1 create mode 100644 dotnet/code-coverage.ps1 create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/MultipleHttpMessageHandlerStub.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContentTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataStreamingChatMessageContentTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIChatMessageContentTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIFunctionToolCallTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIPluginCollectionExtensionsTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIStreamingTextContentTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/RequestFailedExceptionExtensionsTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/AzureOpenAIChatCompletionServiceTests.cs rename dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/{OpenAIChatCompletionTests.cs => OpenAIChatCompletionServiceTests.cs} (80%) create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIMemoryBuilderExtensionsTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIServiceCollectionExtensionsTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_multiple_function_calls_test_response.json create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_single_function_call_test_response.json create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_multiple_function_calls_test_response.txt create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_single_function_call_test_response.txt create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_test_response.txt create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_test_response.json create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_streaming_test_response.txt create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_test_response.json delete mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_generation_test_response.json delete mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_result_test_response.json create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_streaming_test_response.txt create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_test_response.json create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationServiceTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/OpenAITextEmbeddingGenerationServiceTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/AzureOpenAITextGenerationServiceTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/OpenAITextGenerationServiceTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextToImage/OpenAITextToImageServiceTests.cs create mode 100644 dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ToolCallBehaviorTests.cs create mode 100644 dotnet/src/SemanticKernel.UnitTests/Contents/ImageContentTests.cs create mode 100644 dotnet/src/SemanticKernel.UnitTests/Utilities/TypeExtensionsTests.cs diff --git a/.github/workflows/check-coverage.ps1 b/.github/workflows/check-coverage.ps1 new file mode 100644 index 0000000000..39fec480cb --- /dev/null +++ b/.github/workflows/check-coverage.ps1 @@ -0,0 +1,54 @@ +param ( + [string]$JsonReportPath, + [double]$CoverageThreshold +) + +$jsonContent = Get-Content $JsonReportPath -Raw | ConvertFrom-Json +$coverageBelowThreshold = $false + +function Get-FormattedValue($number) { + $formattedNumber = "{0:N1}" -f $number + $icon = if ($number -ge $CoverageThreshold) { '✅' } else { '❌' } + + return "$formattedNumber% $icon" +} + +$lineCoverage = $jsonContent.summary.linecoverage +$branchCoverage = $jsonContent.summary.branchcoverage + +if ($lineCoverage -lt $CoverageThreshold -or $branchCoverage -lt $CoverageThreshold) { + $coverageBelowThreshold = $true +} + +$totalTableData = [PSCustomObject]@{ + 'Metric' = 'Total Coverage' + 'Line Coverage' = Get-FormattedValue $lineCoverage + 'Branch Coverage' = Get-FormattedValue $branchCoverage +} + +$totalTableData | Format-Table -AutoSize + +$assemblyTableData = @() + +foreach ($assembly in $jsonContent.coverage.assemblies) { + $assemblyName = $assembly.name + $assemblyLineCoverage = $assembly.coverage + $assemblyBranchCoverage = $assembly.branchcoverage + + if ($assemblyLineCoverage -lt $CoverageThreshold -or $assemblyBranchCoverage -lt $CoverageThreshold) { + $coverageBelowThreshold = $true + } + + $assemblyTableData += [PSCustomObject]@{ + 'Assembly Name' = $assemblyName + 'Line' = Get-FormattedValue $assemblyLineCoverage + 'Branch' = Get-FormattedValue $assemblyBranchCoverage + } +} + +$assemblyTableData | Format-Table -AutoSize + +if ($coverageBelowThreshold) { + Write-Host "Code coverage is lower than defined threshold: $CoverageThreshold. Stopping the task." + exit 1 +} diff --git a/.github/workflows/dotnet-build-and-test.yml b/.github/workflows/dotnet-build-and-test.yml index fc9f43ff86..755aef1f7d 100644 --- a/.github/workflows/dotnet-build-and-test.yml +++ b/.github/workflows/dotnet-build-and-test.yml @@ -12,6 +12,9 @@ on: merge_group: branches: ["main"] +env: + COVERAGE_THRESHOLD: 80 + concurrency: group: ${{ github.workflow }}-${{ github.event.pull_request.number || github.ref }} cancel-in-progress: true @@ -82,7 +85,7 @@ jobs: run: | export UT_PROJECTS=$(find ./dotnet -type f -name "*.UnitTests.csproj" | grep -v -E "(Planners.Core.UnitTests.csproj|Experimental.Orchestration.Flow.UnitTests.csproj|Experimental.Assistants.UnitTests.csproj)" | tr '\n' ' ') for project in $UT_PROJECTS; do - dotnet test -c ${{ matrix.configuration }} $project --no-build -v Normal --logger trx + dotnet test -c ${{ matrix.configuration }} $project --no-build -v Normal --logger trx --collect:"XPlat Code Coverage" --results-directory:"TestResults/Coverage/" done - name: Run Integration Tests @@ -109,6 +112,20 @@ jobs: Bing__ApiKey: ${{ secrets.BING__APIKEY }} OpenAI__ApiKey: ${{ secrets.OPENAI__APIKEY }} + # Generate test reports and check coverage + - name: Generate test reports + uses: danielpalme/ReportGenerator-GitHub-Action@5.2.0 + with: + reports: "./TestResults/Coverage/**/coverage.cobertura.xml" + targetdir: "./TestResults/Reports" + reporttypes: "JsonSummary" + # Report for production packages only + assemblyfilters: "+Microsoft.SemanticKernel.Abstractions;+Microsoft.SemanticKernel.Core;+Microsoft.SemanticKernel.PromptTemplates.Handlebars;+Microsoft.SemanticKernel.Connectors.OpenAI;+Microsoft.SemanticKernel.Yaml;" + + - name: Check coverage + shell: pwsh + run: .github/workflows/check-coverage.ps1 -JsonReportPath "TestResults/Reports/Summary.json" -CoverageThreshold $env:COVERAGE_THRESHOLD + # This final job is required to satisfy the merge queue. It must only run (or succeed) if no tests failed dotnet-build-and-test-check: if: always() diff --git a/dotnet/SK-dotnet.sln b/dotnet/SK-dotnet.sln index 5cf185efc5..0e42708ea3 100644 --- a/dotnet/SK-dotnet.sln +++ b/dotnet/SK-dotnet.sln @@ -118,6 +118,11 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "System", "System", "{3CDE10 src\InternalUtilities\src\System\EnvExtensions.cs = src\InternalUtilities\src\System\EnvExtensions.cs EndProjectSection EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Type", "Type", "{E85EA4D0-BB7E-4DFD-882F-A76EB8C0B8FF}" + ProjectSection(SolutionItems) = preProject + src\InternalUtilities\src\Type\TypeExtensions.cs = src\InternalUtilities\src\Type\TypeExtensions.cs + EndProjectSection +EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Plugins.Core", "src\Plugins\Plugins.Core\Plugins.Core.csproj", "{0D0C4DAD-E6BC-4504-AE3A-EEA4E35920C1}" EndProject Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "NCalcPlugins", "samples\NCalcPlugins\NCalcPlugins.csproj", "{E6EDAB8F-3406-4DBF-9AAB-DF40DC2CA0FA}" @@ -500,6 +505,7 @@ Global {B00AD427-0047-4850-BEF9-BA8237EA9D8B} = {958AD708-F048-4FAF-94ED-D2F2B92748B9} {1C19D805-3573-4477-BF07-40180FCDE1BD} = {958AD708-F048-4FAF-94ED-D2F2B92748B9} {3CDE10B2-AE8F-4FC4-8D55-92D4AD32E144} = {958AD708-F048-4FAF-94ED-D2F2B92748B9} + {E85EA4D0-BB7E-4DFD-882F-A76EB8C0B8FF} = {958AD708-F048-4FAF-94ED-D2F2B92748B9} {0D0C4DAD-E6BC-4504-AE3A-EEA4E35920C1} = {D6D598DF-C17C-46F4-B2B9-CDE82E2DE132} {E6EDAB8F-3406-4DBF-9AAB-DF40DC2CA0FA} = {FA3720F1-C99A-49B2-9577-A940257098BF} {C754950A-E16C-4F96-9CC7-9328E361B5AF} = {FA3720F1-C99A-49B2-9577-A940257098BF} diff --git a/dotnet/code-coverage.ps1 b/dotnet/code-coverage.ps1 new file mode 100644 index 0000000000..108dbdffa7 --- /dev/null +++ b/dotnet/code-coverage.ps1 @@ -0,0 +1,60 @@ +# This script is for local use to analyze code coverage in more detail using HTML report. + +Param( + [switch]$ProdPackagesOnly = $false +) + +# Generate a timestamp for the current date and time +$timestamp = Get-Date -Format "yyyyMMdd-HHmmss" + +# Define paths +$scriptPath = Get-Item -Path $PSScriptRoot +$coverageOutputPath = Join-Path $scriptPath "TestResults\Coverage\$timestamp" +$reportOutputPath = Join-Path $scriptPath "TestResults\Reports\$timestamp" + +# Create output directories +New-Item -ItemType Directory -Force -Path $coverageOutputPath +New-Item -ItemType Directory -Force -Path $reportOutputPath + +# Find tests for projects ending with 'UnitTests.csproj' +$testProjects = Get-ChildItem $scriptPath -Filter "*UnitTests.csproj" -Recurse + +foreach ($project in $testProjects) { + $testProjectPath = $project.FullName + Write-Host "Running tests for project: $($testProjectPath)" + + # Run tests + dotnet test $testProjectPath ` + --collect:"XPlat Code Coverage" ` + --results-directory:$coverageOutputPath ` + +} + +# Install required tools +& dotnet tool install -g coverlet.console +& dotnet tool install -g dotnet-reportgenerator-globaltool + +# Generate HTML report +if ($ProdPackagesOnly) { + $assemblies = @( + "+Microsoft.SemanticKernel.Abstractions", + "+Microsoft.SemanticKernel.Core", + "+Microsoft.SemanticKernel.PromptTemplates.Handlebars", + "+Microsoft.SemanticKernel.Connectors.OpenAI", + "+Microsoft.SemanticKernel.Yaml" + ) + + $assemblyFilters = $assemblies -join ";" + + # Generate report for production assemblies only + & reportgenerator -reports:"$coverageOutputPath/**/coverage.cobertura.xml" -targetdir:$reportOutputPath -reporttypes:Html -assemblyfilters:$assemblyFilters +} +else { + & reportgenerator -reports:"$coverageOutputPath/**/coverage.cobertura.xml" -targetdir:$reportOutputPath -reporttypes:Html +} + +Write-Host "Code coverage report generated at: $reportOutputPath" + +# Open report +$reportIndexHtml = Join-Path $reportOutputPath "index.html" +Invoke-Item -Path $reportIndexHtml diff --git a/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIClientCore.cs b/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIClientCore.cs index 91888c5073..9155050518 100644 --- a/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIClientCore.cs +++ b/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIClientCore.cs @@ -2,7 +2,6 @@ using System; using System.Net.Http; -using System.Runtime.CompilerServices; using Azure; using Azure.AI.OpenAI; using Azure.Core; @@ -98,16 +97,4 @@ internal sealed class AzureOpenAIClientCore : ClientCore this.AddAttribute(DeploymentNameKey, deploymentName); } - - /// - /// Logs Azure OpenAI action details. - /// - /// Caller member name. Populated automatically by runtime. - internal void LogActionDetails([CallerMemberName] string? callerMemberName = default) - { - if (this.Logger.IsEnabled(LogLevel.Information)) - { - this.Logger.LogInformation("Action: {Action}. Azure OpenAI Deployment Name: {DeploymentName}.", callerMemberName, this.DeploymentOrModelName); - } - } } diff --git a/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContent.cs b/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContent.cs index 5f84d7148f..04b0e7a2c0 100644 --- a/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContent.cs +++ b/dotnet/src/Connectors/Connectors.OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContent.cs @@ -30,7 +30,8 @@ public sealed class AzureOpenAIWithDataChatMessageContent : ChatMessageContent : base(default, string.Empty, modelId, chatChoice, System.Text.Encoding.UTF8, CreateMetadataDictionary(metadata)) { // An assistant message content must be present, otherwise the chat is not valid. - var chatMessage = chatChoice.Messages.First(m => string.Equals(m.Role, AuthorRole.Assistant.Label, StringComparison.OrdinalIgnoreCase)); + var chatMessage = chatChoice.Messages.FirstOrDefault(m => string.Equals(m.Role, AuthorRole.Assistant.Label, StringComparison.OrdinalIgnoreCase)) ?? + throw new ArgumentException("Chat is not valid. Chat message does not contain any messages with 'assistant' role."); this.Content = chatMessage.Content; this.Role = new AuthorRole(chatMessage.Role); diff --git a/dotnet/src/Connectors/Connectors.OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationService.cs b/dotnet/src/Connectors/Connectors.OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationService.cs index f1277a3dfd..381c86c6aa 100644 --- a/dotnet/src/Connectors/Connectors.OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationService.cs +++ b/dotnet/src/Connectors/Connectors.OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationService.cs @@ -93,7 +93,6 @@ public sealed class AzureOpenAITextEmbeddingGenerationService : ITextEmbeddingGe Kernel? kernel = null, CancellationToken cancellationToken = default) { - this._core.LogActionDetails(); return this._core.GetEmbeddingsAsync(data, kernel, cancellationToken); } } diff --git a/dotnet/src/Connectors/Connectors.OpenAI/TextToImage/OpenAITextToImageService.cs b/dotnet/src/Connectors/Connectors.OpenAI/TextToImage/OpenAITextToImageService.cs index 72531434ca..837b877845 100644 --- a/dotnet/src/Connectors/Connectors.OpenAI/TextToImage/OpenAITextToImageService.cs +++ b/dotnet/src/Connectors/Connectors.OpenAI/TextToImage/OpenAITextToImageService.cs @@ -2,7 +2,6 @@ using System; using System.Collections.Generic; -using System.Diagnostics; using System.Diagnostics.CodeAnalysis; using System.Net.Http; using System.Text.Json; @@ -87,10 +86,7 @@ public sealed class OpenAITextToImageService : ITextToImageService string format, Func extractResponse, CancellationToken cancellationToken) { - Debug.Assert(width == height); - Debug.Assert(width is 256 or 512 or 1024); - Debug.Assert(format is "url" or "b64_json"); - Debug.Assert(extractResponse is not null); + Verify.NotNull(extractResponse); var requestBody = JsonSerializer.Serialize(new TextToImageRequest { diff --git a/dotnet/src/Connectors/Connectors.UnitTests/Connectors.UnitTests.csproj b/dotnet/src/Connectors/Connectors.UnitTests/Connectors.UnitTests.csproj index 1c7a297872..a541b834ba 100644 --- a/dotnet/src/Connectors/Connectors.UnitTests/Connectors.UnitTests.csproj +++ b/dotnet/src/Connectors/Connectors.UnitTests/Connectors.UnitTests.csproj @@ -27,14 +27,17 @@ runtime; build; native; contentfiles; analyzers; buildtransitive all + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + - + @@ -55,16 +58,10 @@ - + Always - - Always - - - Always - - + Always diff --git a/dotnet/src/Connectors/Connectors.UnitTests/MultipleHttpMessageHandlerStub.cs b/dotnet/src/Connectors/Connectors.UnitTests/MultipleHttpMessageHandlerStub.cs new file mode 100644 index 0000000000..f83ac864d0 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/MultipleHttpMessageHandlerStub.cs @@ -0,0 +1,53 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.Net.Http; +using System.Net.Http.Headers; +using System.Threading; +using System.Threading.Tasks; + +namespace SemanticKernel.Connectors.UnitTests; + +internal sealed class MultipleHttpMessageHandlerStub : DelegatingHandler +{ + private int _callIteration = 0; + + public List RequestHeaders { get; private set; } + + public List ContentHeaders { get; private set; } + + public List RequestContents { get; private set; } + + public List RequestUris { get; private set; } + + public List Methods { get; private set; } + + public List ResponsesToReturn { get; set; } + + public MultipleHttpMessageHandlerStub() + { + this.RequestHeaders = []; + this.ContentHeaders = []; + this.RequestContents = []; + this.RequestUris = []; + this.Methods = []; + this.ResponsesToReturn = []; + } + + protected override async Task SendAsync(HttpRequestMessage request, CancellationToken cancellationToken) + { + this._callIteration++; + + this.Methods.Add(request.Method); + this.RequestUris.Add(request.RequestUri); + this.RequestHeaders.Add(request.Headers); + this.ContentHeaders.Add(request.Content?.Headers); + + var content = request.Content == null ? null : await request.Content.ReadAsByteArrayAsync(cancellationToken); + + this.RequestContents.Add(content); + + return await Task.FromResult(this.ResponsesToReturn[this._callIteration - 1]); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContentTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContentTests.cs new file mode 100644 index 0000000000..76d5c6b7d8 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataChatMessageContentTests.cs @@ -0,0 +1,70 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using Microsoft.SemanticKernel.ChatCompletion; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class AzureOpenAIWithDataChatMessageContentTests +{ + [Fact] + public void ConstructorThrowsExceptionWhenAssistantMessageIsNotProvided() + { + // Arrange + var choice = new ChatWithDataChoice(); + + // Act & Assert + var exception = Assert.Throws(() => new AzureOpenAIWithDataChatMessageContent(choice, "model-id")); + + Assert.Contains("Chat is not valid", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public void ConstructorReturnsInstanceWithNullToolContent() + { + // Arrange + var choice = new ChatWithDataChoice { Messages = [new() { Content = "Assistant content", Role = "assistant" }] }; + + // Act + var content = new AzureOpenAIWithDataChatMessageContent(choice, "model-id"); + + // Assert + Assert.Equal("Assistant content", content.Content); + Assert.Equal(AuthorRole.Assistant, content.Role); + + Assert.Null(content.ToolContent); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorReturnsInstanceWithNonNullToolContent(bool includeMetadata) + { + // Arrange + var choice = new ChatWithDataChoice + { + Messages = [ + new() { Content = "Assistant content", Role = "assistant" }, + new() { Content = "Tool content", Role = "tool" }] + }; + + // Act + var content = includeMetadata ? + new AzureOpenAIWithDataChatMessageContent(choice, "model-id", new Dictionary()) : + new AzureOpenAIWithDataChatMessageContent(choice, "model-id"); + + // Assert + Assert.Equal("Assistant content", content.Content); + Assert.Equal("Tool content", content.ToolContent); + Assert.Equal(AuthorRole.Assistant, content.Role); + + Assert.NotNull(content.Metadata); + Assert.Equal("Tool content", content.Metadata["ToolContent"]); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataStreamingChatMessageContentTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataStreamingChatMessageContentTests.cs new file mode 100644 index 0000000000..d3fd86820e --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/AzureOpenAIWithDataStreamingChatMessageContentTests.cs @@ -0,0 +1,59 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class AzureOpenAIWithDataStreamingChatMessageContentTests +{ + [Theory] + [MemberData(nameof(ValidChoices))] + public void ConstructorWithValidChoiceSetsNonEmptyContent(object choice, string expectedContent) + { + // Arrange + var streamingChoice = choice as ChatWithDataStreamingChoice; + + // Act + var content = new AzureOpenAIWithDataStreamingChatMessageContent(streamingChoice!, 0, "model-id"); + + // Assert + Assert.Equal(expectedContent, content.Content); + } + + [Theory] + [MemberData(nameof(InvalidChoices))] + public void ConstructorWithInvalidChoiceSetsNullContent(object choice) + { + // Arrange + var streamingChoice = choice as ChatWithDataStreamingChoice; + + // Act + var content = new AzureOpenAIWithDataStreamingChatMessageContent(streamingChoice!, 0, "model-id"); + + // Assert + Assert.Null(content.Content); + } + + public static IEnumerable ValidChoices + { + get + { + yield return new object[] { new ChatWithDataStreamingChoice { Messages = [new() { Delta = new() { Content = "Content 1" } }] }, "Content 1" }; + yield return new object[] { new ChatWithDataStreamingChoice { Messages = [new() { Delta = new() { Content = "Content 2", Role = "Assistant" } }] }, "Content 2" }; + } + } + + public static IEnumerable InvalidChoices + { + get + { + yield return new object[] { new ChatWithDataStreamingChoice { Messages = [new() { EndTurn = true }] } }; + yield return new object[] { new ChatWithDataStreamingChoice { Messages = [new() { Delta = new() { Content = "Content", Role = "tool" } }] } }; + } + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIChatMessageContentTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIChatMessageContentTests.cs new file mode 100644 index 0000000000..6f7f271b3c --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIChatMessageContentTests.cs @@ -0,0 +1,104 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using Azure.AI.OpenAI; +using Microsoft.SemanticKernel.ChatCompletion; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIChatMessageContentTests +{ + [Fact] + public void ConstructorsWorkCorrectly() + { + // Arrange + List toolCalls = [new FakeChatCompletionsToolCall("id")]; + + // Act + var content1 = new OpenAIChatMessageContent(new ChatRole("user"), "content1", "model-id1", toolCalls); + var content2 = new OpenAIChatMessageContent(AuthorRole.User, "content2", "model-id2", toolCalls); + + // Assert + this.AssertChatMessageContent(AuthorRole.User, "content1", "model-id1", toolCalls, content1); + this.AssertChatMessageContent(AuthorRole.User, "content2", "model-id2", toolCalls, content2); + } + + [Fact] + public void GetOpenAIFunctionToolCallsReturnsCorrectList() + { + // Arrange + List toolCalls = [ + new ChatCompletionsFunctionToolCall("id1", "name", string.Empty), + new ChatCompletionsFunctionToolCall("id2", "name", string.Empty), + new FakeChatCompletionsToolCall("id3"), + new FakeChatCompletionsToolCall("id4")]; + + var content1 = new OpenAIChatMessageContent(AuthorRole.User, "content", "model-id", toolCalls); + var content2 = new OpenAIChatMessageContent(AuthorRole.User, "content", "model-id", []); + + // Act + var actualToolCalls1 = content1.GetOpenAIFunctionToolCalls(); + var actualToolCalls2 = content2.GetOpenAIFunctionToolCalls(); + + // Assert + Assert.Equal(2, actualToolCalls1.Count); + Assert.Equal("id1", actualToolCalls1[0].Id); + Assert.Equal("id2", actualToolCalls1[1].Id); + + Assert.Empty(actualToolCalls2); + } + + [Fact] + public void MetadataIsInitializedCorrectly() + { + // Arrange + var metadata = new Dictionary { { "key", "value" } }; + List toolCalls = [ + new ChatCompletionsFunctionToolCall("id1", "name", string.Empty), + new ChatCompletionsFunctionToolCall("id2", "name", string.Empty), + new FakeChatCompletionsToolCall("id3"), + new FakeChatCompletionsToolCall("id4")]; + + // Act + var content1 = new OpenAIChatMessageContent(AuthorRole.User, "content1", "model-id1", [], metadata); + var content2 = new OpenAIChatMessageContent(AuthorRole.User, "content2", "model-id2", toolCalls, metadata); + + // Assert + Assert.NotNull(content1.Metadata); + Assert.Single(content1.Metadata); + + Assert.NotNull(content2.Metadata); + Assert.Equal(2, content2.Metadata.Count); + Assert.Equal("value", content2.Metadata["key"]); + + Assert.IsType>(content2.Metadata["ChatResponseMessage.FunctionToolCalls"]); + + var actualToolCalls = content2.Metadata["ChatResponseMessage.FunctionToolCalls"] as List; + Assert.NotNull(actualToolCalls); + + Assert.Equal(2, actualToolCalls.Count); + Assert.Equal("id1", actualToolCalls[0].Id); + Assert.Equal("id2", actualToolCalls[1].Id); + } + + private void AssertChatMessageContent( + AuthorRole expectedRole, + string expectedContent, + string expectedModelId, + IReadOnlyList expectedToolCalls, + OpenAIChatMessageContent actualContent) + { + Assert.Equal(expectedRole, actualContent.Role); + Assert.Equal(expectedContent, actualContent.Content); + Assert.Equal(expectedModelId, actualContent.ModelId); + Assert.Same(expectedToolCalls, actualContent.ToolCalls); + } + + private sealed class FakeChatCompletionsToolCall(string id) : ChatCompletionsToolCall(id) + { } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIFunctionToolCallTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIFunctionToolCallTests.cs new file mode 100644 index 0000000000..9b4d53adb1 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIFunctionToolCallTests.cs @@ -0,0 +1,81 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Text; +using Azure.AI.OpenAI; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIFunctionToolCallTests +{ + [Theory] + [InlineData("MyFunction", "MyFunction")] + [InlineData("MyPlugin_MyFunction", "MyPlugin_MyFunction")] + public void FullyQualifiedNameReturnsValidName(string toolCallName, string expectedName) + { + // Arrange + var toolCall = new ChatCompletionsFunctionToolCall("id", toolCallName, string.Empty); + var openAIFunctionToolCall = new OpenAIFunctionToolCall(toolCall); + + // Act & Assert + Assert.Equal(expectedName, openAIFunctionToolCall.FullyQualifiedName); + } + + [Fact] + public void ToStringReturnsCorrectValue() + { + // Arrange + var toolCall = new ChatCompletionsFunctionToolCall("id", "MyPlugin_MyFunction", "{\n \"location\": \"San Diego\",\n \"max_price\": 300\n}"); + var openAIFunctionToolCall = new OpenAIFunctionToolCall(toolCall); + + // Act & Assert + Assert.Equal("MyPlugin_MyFunction(location:San Diego, max_price:300)", openAIFunctionToolCall.ToString()); + } + + [Fact] + public void ConvertToolCallUpdatesWithEmptyIndexesReturnsEmptyToolCalls() + { + // Arrange + var toolCallIdsByIndex = new Dictionary(); + var functionNamesByIndex = new Dictionary(); + var functionArgumentBuildersByIndex = new Dictionary(); + + // Act + var toolCalls = OpenAIFunctionToolCall.ConvertToolCallUpdatesToChatCompletionsFunctionToolCalls( + ref toolCallIdsByIndex, + ref functionNamesByIndex, + ref functionArgumentBuildersByIndex); + + // Assert + Assert.Empty(toolCalls); + } + + [Fact] + public void ConvertToolCallUpdatesWithNotEmptyIndexesReturnsNotEmptyToolCalls() + { + // Arrange + var toolCallIdsByIndex = new Dictionary { { 3, "test-id" } }; + var functionNamesByIndex = new Dictionary { { 3, "test-function" } }; + var functionArgumentBuildersByIndex = new Dictionary { { 3, new("test-argument") } }; + + // Act + var toolCalls = OpenAIFunctionToolCall.ConvertToolCallUpdatesToChatCompletionsFunctionToolCalls( + ref toolCallIdsByIndex, + ref functionNamesByIndex, + ref functionArgumentBuildersByIndex); + + // Assert + Assert.Single(toolCalls); + + var toolCall = toolCalls[0]; + + Assert.Equal("test-id", toolCall.Id); + Assert.Equal("test-function", toolCall.Name); + Assert.Equal("test-argument", toolCall.Arguments); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIPluginCollectionExtensionsTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIPluginCollectionExtensionsTests.cs new file mode 100644 index 0000000000..ec535ba2b4 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIPluginCollectionExtensionsTests.cs @@ -0,0 +1,74 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Azure.AI.OpenAI; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIPluginCollectionExtensionsTests +{ + [Fact] + public void TryGetFunctionAndArgumentsWithNonExistingFunctionReturnsFalse() + { + // Arrange + var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", []); + var plugins = new KernelPluginCollection([plugin]); + + var toolCall = new ChatCompletionsFunctionToolCall("id", "MyPlugin_MyFunction", string.Empty); + + // Act + var result = plugins.TryGetFunctionAndArguments(toolCall, out var actualFunction, out var actualArguments); + + // Assert + Assert.False(result); + Assert.Null(actualFunction); + Assert.Null(actualArguments); + } + + [Fact] + public void TryGetFunctionAndArgumentsWithoutArgumentsReturnsTrue() + { + // Arrange + var function = KernelFunctionFactory.CreateFromMethod(() => "Result", "MyFunction"); + var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", [function]); + + var plugins = new KernelPluginCollection([plugin]); + var toolCall = new ChatCompletionsFunctionToolCall("id", "MyPlugin_MyFunction", string.Empty); + + // Act + var result = plugins.TryGetFunctionAndArguments(toolCall, out var actualFunction, out var actualArguments); + + // Assert + Assert.True(result); + Assert.Same(function, actualFunction); + Assert.Null(actualArguments); + } + + [Fact] + public void TryGetFunctionAndArgumentsWithArgumentsReturnsTrue() + { + // Arrange + var function = KernelFunctionFactory.CreateFromMethod(() => "Result", "MyFunction"); + var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", [function]); + + var plugins = new KernelPluginCollection([plugin]); + var toolCall = new ChatCompletionsFunctionToolCall("id", "MyPlugin_MyFunction", "{\n \"location\": \"San Diego\",\n \"max_price\": 300\n,\n \"null_argument\": null\n}"); + + // Act + var result = plugins.TryGetFunctionAndArguments(toolCall, out var actualFunction, out var actualArguments); + + // Assert + Assert.True(result); + Assert.Same(function, actualFunction); + + Assert.NotNull(actualArguments); + Assert.Equal("San Diego", actualArguments["location"]); + Assert.Equal("300", actualArguments["max_price"]); + Assert.Null(actualArguments["null_argument"]); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIStreamingTextContentTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIStreamingTextContentTests.cs new file mode 100644 index 0000000000..fd0a830cc2 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/OpenAIStreamingTextContentTests.cs @@ -0,0 +1,42 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Text; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIStreamingTextContentTests +{ + [Fact] + public void ToByteArrayWorksCorrectly() + { + // Arrange + var expectedBytes = Encoding.UTF8.GetBytes("content"); + var content = new OpenAIStreamingTextContent("content", 0, "model-id"); + + // Act + var actualBytes = content.ToByteArray(); + + // Assert + Assert.Equal(expectedBytes, actualBytes); + } + + [Theory] + [InlineData(null, "")] + [InlineData("content", "content")] + public void ToStringWorksCorrectly(string? content, string expectedString) + { + // Arrange + var textContent = new OpenAIStreamingTextContent(content!, 0, "model-id"); + + // Act + var actualString = textContent.ToString(); + + // Assert + Assert.Equal(expectedString, actualString); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/RequestFailedExceptionExtensionsTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/RequestFailedExceptionExtensionsTests.cs new file mode 100644 index 0000000000..4267c57435 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/AzureSdk/RequestFailedExceptionExtensionsTests.cs @@ -0,0 +1,79 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Net; +using Azure; +using Azure.Core; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.AzureSdk; + +/// +/// Unit tests for class. +/// +public sealed class RequestFailedExceptionExtensionsTests +{ + [Theory] + [InlineData(0, null)] + [InlineData(500, HttpStatusCode.InternalServerError)] + public void ToHttpOperationExceptionWithStatusReturnsValidException(int responseStatus, HttpStatusCode? httpStatusCode) + { + // Arrange + var exception = new RequestFailedException(responseStatus, "Error Message"); + + // Act + var actualException = exception.ToHttpOperationException(); + + // Assert + Assert.IsType(actualException); + Assert.Equal(httpStatusCode, actualException.StatusCode); + Assert.Equal("Error Message", actualException.Message); + Assert.Same(exception, actualException.InnerException); + } + + [Fact] + public void ToHttpOperationExceptionWithContentReturnsValidException() + { + // Arrange + using var response = new FakeResponse("Response Content", 500); + var exception = new RequestFailedException(response); + + // Act + var actualException = exception.ToHttpOperationException(); + + // Assert + Assert.IsType(actualException); + Assert.Equal(HttpStatusCode.InternalServerError, actualException.StatusCode); + Assert.Equal("Response Content", actualException.ResponseContent); + Assert.Same(exception, actualException.InnerException); + } + + #region private + + private sealed class FakeResponse(string responseContent, int status) : Response + { + private readonly string _responseContent = responseContent; + private readonly int _status = status; + private readonly IEnumerable _headers = new List(); + + public override BinaryData Content => BinaryData.FromString(this._responseContent); + public override int Status => this._status; + public override string ReasonPhrase => "Reason Phrase"; + public override Stream? ContentStream { get => null; set => throw new NotImplementedException(); } + public override string ClientRequestId { get => "Client Request Id"; set => throw new NotImplementedException(); } + + public override void Dispose() { } + protected override bool ContainsHeader(string name) => throw new NotImplementedException(); + protected override IEnumerable EnumerateHeaders() => this._headers; +#pragma warning disable CS8765 // Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes). + protected override bool TryGetHeader(string name, out string? value) => throw new NotImplementedException(); + protected override bool TryGetHeaderValues(string name, out IEnumerable? values) => throw new NotImplementedException(); +#pragma warning restore CS8765 // Nullability of type of parameter doesn't match overridden member (possibly because of nullability attributes). + } + + #endregion +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/AzureOpenAIChatCompletionServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/AzureOpenAIChatCompletionServiceTests.cs new file mode 100644 index 0000000000..9374dd6f72 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/AzureOpenAIChatCompletionServiceTests.cs @@ -0,0 +1,583 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Text.Json; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Azure.Core; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.ChatCompletion; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.ChatCompletion; + +/// +/// Unit tests for +/// +public sealed class AzureOpenAIChatCompletionServiceTests : IDisposable +{ + private readonly MultipleHttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public AzureOpenAIChatCompletionServiceTests() + { + this._messageHandlerStub = new MultipleHttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + + var mockLogger = new Mock(); + + mockLogger.Setup(l => l.IsEnabled(It.IsAny())).Returns(true); + + this._mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny())).Returns(mockLogger.Object); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithTokenCredentialWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var service = includeLoggerFactory ? + new AzureOpenAIChatCompletionService("deployment", "https://endpoint", credentials, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAIChatCompletionService("deployment", "https://endpoint", credentials, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new AzureOpenAIChatCompletionService("deployment", client, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAIChatCompletionService("deployment", client, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Fact] + public async Task GetTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) + }); + + // Act + var result = await service.GetTextContentsAsync("Prompt"); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat response", result[0].Text); + + var usage = result[0].Metadata?["Usage"] as CompletionsUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetChatMessageContentsWithEmptyChoicesThrowsExceptionAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent("{\"id\":\"response-id\",\"object\":\"chat.completion\",\"created\":1704208954,\"model\":\"gpt-4\",\"choices\":[],\"usage\":{\"prompt_tokens\":55,\"completion_tokens\":100,\"total_tokens\":155},\"system_fingerprint\":null}") + }); + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GetChatMessageContentsAsync([])); + + Assert.Equal("Chat completions not found", exception.Message); + } + + [Theory] + [InlineData(0)] + [InlineData(129)] + public async Task GetChatMessageContentsWithInvalidResultsPerPromptValueThrowsExceptionAsync(int resultsPerPrompt) + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings { ResultsPerPrompt = resultsPerPrompt }; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GetChatMessageContentsAsync([], settings)); + + Assert.Contains("The value must be in range between", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task GetChatMessageContentsHandlesSettingsCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings() + { + MaxTokens = 123, + Temperature = 0.6, + TopP = 0.5, + FrequencyPenalty = 1.6, + PresencePenalty = 1.2, + ResultsPerPrompt = 5, + Seed = 567, + TokenSelectionBiases = new Dictionary { { 2, 3 } }, + StopSequences = ["stop_sequence"] + }; + + var chatHistory = new ChatHistory(); + chatHistory.AddUserMessage("User Message"); + chatHistory.AddSystemMessage("System Message"); + chatHistory.AddAssistantMessage("Assistant Message"); + + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) + }); + + // Act + var result = await service.GetChatMessageContentsAsync(chatHistory, settings); + + // Assert + var requestContent = this._messageHandlerStub.RequestContents[0]; + + Assert.NotNull(requestContent); + + var content = JsonSerializer.Deserialize(Encoding.UTF8.GetString(requestContent)); + + var messages = content.GetProperty("messages"); + + var userMessage = messages[0]; + var systemMessage = messages[1]; + var assistantMessage = messages[2]; + + Assert.Equal("user", userMessage.GetProperty("role").GetString()); + Assert.Equal("User Message", userMessage.GetProperty("content").GetString()); + + Assert.Equal("system", systemMessage.GetProperty("role").GetString()); + Assert.Equal("System Message", systemMessage.GetProperty("content").GetString()); + + Assert.Equal("assistant", assistantMessage.GetProperty("role").GetString()); + Assert.Equal("Assistant Message", assistantMessage.GetProperty("content").GetString()); + + Assert.Equal(123, content.GetProperty("max_tokens").GetInt32()); + Assert.Equal(0.6, content.GetProperty("temperature").GetDouble()); + Assert.Equal(0.5, content.GetProperty("top_p").GetDouble()); + Assert.Equal(1.6, content.GetProperty("frequency_penalty").GetDouble()); + Assert.Equal(1.2, content.GetProperty("presence_penalty").GetDouble()); + Assert.Equal(5, content.GetProperty("n").GetInt32()); + Assert.Equal(567, content.GetProperty("seed").GetInt32()); + Assert.Equal(3, content.GetProperty("logit_bias").GetProperty("2").GetInt32()); + Assert.Equal("stop_sequence", content.GetProperty("stop")[0].GetString()); + } + + [Theory] + [MemberData(nameof(ResponseFormats))] + public async Task GetChatMessageContentsHandlesResponseFormatCorrectlyAsync(object responseFormat, string? expectedResponseType) + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings + { + ResponseFormat = responseFormat + }; + + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) + }); + + // Act + var result = await service.GetChatMessageContentsAsync([], settings); + + // Assert + var requestContent = this._messageHandlerStub.RequestContents[0]; + + Assert.NotNull(requestContent); + + var content = JsonSerializer.Deserialize(Encoding.UTF8.GetString(requestContent)); + + Assert.Equal(expectedResponseType, content.GetProperty("response_format").GetProperty("type").GetString()); + } + + [Theory] + [MemberData(nameof(ToolCallBehaviors))] + public async Task GetChatMessageContentsWorksCorrectlyAsync(ToolCallBehavior behavior) + { + // Arrange + var kernel = Kernel.CreateBuilder().Build(); + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = behavior }; + + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) + }); + + // Act + var result = await service.GetChatMessageContentsAsync([], settings, kernel); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat response", result[0].Content); + + var usage = result[0].Metadata?["Usage"] as CompletionsUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetChatMessageContentsWithFunctionCallAsync() + { + // Arrange + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function1 = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + var function2 = KernelFunctionFactory.CreateFromMethod((string argument) => + { + functionCallCount++; + throw new ArgumentException("Some exception"); + }, "FunctionWithException"); + + kernel.Plugins.Add(KernelPluginFactory.CreateFromFunctions("MyPlugin", [function1, function2])); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions }; + + using var response1 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_multiple_function_calls_test_response.json")) }; + using var response2 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) }; + + this._messageHandlerStub.ResponsesToReturn = [response1, response2]; + + // Act + var result = await service.GetChatMessageContentsAsync([], settings, kernel); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat response", result[0].Content); + + Assert.Equal(2, functionCallCount); + } + + [Fact] + public async Task GetChatMessageContentsWithFunctionCallMaximumAutoInvokeAttemptsAsync() + { + // Arrange + const int DefaultMaximumAutoInvokeAttempts = 5; + const int AutoInvokeResponsesCount = 6; + + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + kernel.Plugins.Add(KernelPluginFactory.CreateFromFunctions("MyPlugin", [function])); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions }; + + var responses = new List(); + + for (var i = 0; i < AutoInvokeResponsesCount; i++) + { + responses.Add(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_single_function_call_test_response.json")) }); + } + + this._messageHandlerStub.ResponsesToReturn = responses; + + // Act + var result = await service.GetChatMessageContentsAsync([], settings, kernel); + + // Assert + Assert.Equal(DefaultMaximumAutoInvokeAttempts, functionCallCount); + } + + [Fact] + public async Task GetChatMessageContentsWithRequiredFunctionCallAsync() + { + // Arrange + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", [function]); + var openAIFunction = plugin.GetFunctionsMetadata().First().ToOpenAIFunction(); + + kernel.Plugins.Add(plugin); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.RequireFunction(openAIFunction, autoInvoke: true) }; + + using var response1 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_single_function_call_test_response.json")) }; + using var response2 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_test_response.json")) }; + + this._messageHandlerStub.ResponsesToReturn = [response1, response2]; + + // Act + var result = await service.GetChatMessageContentsAsync([], settings, kernel); + + // Assert + Assert.Equal(1, functionCallCount); + + var requestContents = this._messageHandlerStub.RequestContents; + + Assert.Equal(2, requestContents.Count); + + requestContents.ForEach(Assert.NotNull); + + var firstContent = Encoding.UTF8.GetString(requestContents[0]!); + var secondContent = Encoding.UTF8.GetString(requestContents[1]!); + + var firstContentJson = JsonSerializer.Deserialize(firstContent); + var secondContentJson = JsonSerializer.Deserialize(secondContent); + + Assert.Equal(1, firstContentJson.GetProperty("tools").GetArrayLength()); + Assert.Equal("MyPlugin_GetCurrentWeather", firstContentJson.GetProperty("tool_choice").GetProperty("function").GetProperty("name").GetString()); + + Assert.Equal("none", secondContentJson.GetProperty("tool_choice").GetString()); + } + + [Fact] + public async Task GetStreamingTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }); + + // Act & Assert + await foreach (var chunk in service.GetStreamingTextContentsAsync("Prompt")) + { + Assert.Equal("Test chat streaming response", chunk.Text); + } + } + + [Fact] + public async Task GetStreamingChatMessageContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponsesToReturn.Add(new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }); + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([])) + { + Assert.Equal("Test chat streaming response", chunk.Content); + } + } + + [Fact] + public async Task GetStreamingChatMessageContentsWithFunctionCallAsync() + { + // Arrange + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function1 = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + var function2 = KernelFunctionFactory.CreateFromMethod((string argument) => + { + functionCallCount++; + throw new ArgumentException("Some exception"); + }, "FunctionWithException"); + + kernel.Plugins.Add(KernelPluginFactory.CreateFromFunctions("MyPlugin", [function1, function2])); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions }; + + using var response1 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_streaming_multiple_function_calls_test_response.txt")) }; + using var response2 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt")) }; + + this._messageHandlerStub.ResponsesToReturn = [response1, response2]; + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([], settings, kernel)) + { + Assert.Equal("Test chat streaming response", chunk.Content); + } + + Assert.Equal(2, functionCallCount); + } + + [Fact] + public async Task GetStreamingChatMessageContentsWithFunctionCallMaximumAutoInvokeAttemptsAsync() + { + // Arrange + const int DefaultMaximumAutoInvokeAttempts = 5; + const int AutoInvokeResponsesCount = 6; + + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + kernel.Plugins.Add(KernelPluginFactory.CreateFromFunctions("MyPlugin", [function])); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.AutoInvokeKernelFunctions }; + + var responses = new List(); + + for (var i = 0; i < AutoInvokeResponsesCount; i++) + { + responses.Add(new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_streaming_single_function_call_test_response.txt")) }); + } + + this._messageHandlerStub.ResponsesToReturn = responses; + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([], settings, kernel)) + { + Assert.Equal("Test chat streaming response", chunk.Content); + } + + Assert.Equal(DefaultMaximumAutoInvokeAttempts, functionCallCount); + } + + [Fact] + public async Task GetStreamingChatMessageContentsWithRequiredFunctionCallAsync() + { + // Arrange + int functionCallCount = 0; + + var kernel = Kernel.CreateBuilder().Build(); + var function = KernelFunctionFactory.CreateFromMethod((string location) => + { + functionCallCount++; + return "Some weather"; + }, "GetCurrentWeather"); + + var plugin = KernelPluginFactory.CreateFromFunctions("MyPlugin", [function]); + var openAIFunction = plugin.GetFunctionsMetadata().First().ToOpenAIFunction(); + + kernel.Plugins.Add(plugin); + + var service = new AzureOpenAIChatCompletionService("deployment", "https://endpoint", "api-key", "model-id", this._httpClient, this._mockLoggerFactory.Object); + var settings = new OpenAIPromptExecutionSettings() { ToolCallBehavior = ToolCallBehavior.RequireFunction(openAIFunction, autoInvoke: true) }; + + using var response1 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_streaming_single_function_call_test_response.txt")) }; + using var response2 = new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt")) }; + + this._messageHandlerStub.ResponsesToReturn = [response1, response2]; + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([], settings, kernel)) + { + Assert.Equal("Test chat streaming response", chunk.Content); + } + + Assert.Equal(1, functionCallCount); + + var requestContents = this._messageHandlerStub.RequestContents; + + Assert.Equal(2, requestContents.Count); + + requestContents.ForEach(Assert.NotNull); + + var firstContent = Encoding.UTF8.GetString(requestContents[0]!); + var secondContent = Encoding.UTF8.GetString(requestContents[1]!); + + var firstContentJson = JsonSerializer.Deserialize(firstContent); + var secondContentJson = JsonSerializer.Deserialize(secondContent); + + Assert.Equal(1, firstContentJson.GetProperty("tools").GetArrayLength()); + Assert.Equal("MyPlugin_GetCurrentWeather", firstContentJson.GetProperty("tool_choice").GetProperty("function").GetProperty("name").GetString()); + + Assert.Equal("none", secondContentJson.GetProperty("tool_choice").GetString()); + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } + + public static TheoryData ToolCallBehaviors => new() + { + ToolCallBehavior.EnableKernelFunctions, + ToolCallBehavior.AutoInvokeKernelFunctions + }; + + public static TheoryData ResponseFormats => new() + { + { new FakeChatCompletionsResponseFormat(), null }, + { "json_object", "json_object" }, + { "text", "text" } + }; + + private sealed class FakeChatCompletionsResponseFormat : ChatCompletionsResponseFormat { } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionServiceTests.cs similarity index 80% rename from dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionTests.cs rename to dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionServiceTests.cs index c693c8cd36..641339ee37 100644 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionTests.cs +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletion/OpenAIChatCompletionServiceTests.cs @@ -3,14 +3,19 @@ using System; using System.Collections.Generic; using System.Globalization; +using System.IO; +using System.Net; using System.Net.Http; using System.Text; using System.Text.Json; using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Microsoft.Extensions.Logging; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.ChatCompletion; using Microsoft.SemanticKernel.Connectors.OpenAI; using Microsoft.SemanticKernel.TextGeneration; +using Moq; using Xunit; namespace SemanticKernel.Connectors.UnitTests.OpenAI.ChatCompletion; @@ -18,17 +23,19 @@ namespace SemanticKernel.Connectors.UnitTests.OpenAI.ChatCompletion; /// /// Unit tests for /// -public sealed class OpenAIChatCompletionTests : IDisposable +public sealed class OpenAIChatCompletionServiceTests : IDisposable { private readonly HttpMessageHandlerStub _messageHandlerStub; private readonly HttpClient _httpClient; private readonly OpenAIFunction _timepluginDate, _timepluginNow; private readonly OpenAIPromptExecutionSettings _executionSettings; + private readonly Mock _mockLoggerFactory; - public OpenAIChatCompletionTests() + public OpenAIChatCompletionServiceTests() { this._messageHandlerStub = new HttpMessageHandlerStub(); this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); IList functions = KernelPluginFactory.CreateFromFunctions("TimePlugin", new[] { @@ -45,6 +52,37 @@ public sealed class OpenAIChatCompletionTests : IDisposable }; } + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new OpenAIChatCompletionService("model-id", "api-key", "organization", loggerFactory: this._mockLoggerFactory.Object) : + new OpenAIChatCompletionService("model-id", "api-key", "organization"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new OpenAIChatCompletionService("model-id", client, loggerFactory: this._mockLoggerFactory.Object) : + new OpenAIChatCompletionService("model-id", client); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + [Fact] public async Task ItCreatesCorrectFunctionToolCallsWhenUsingAutoAsync() { @@ -163,6 +201,44 @@ public sealed class OpenAIChatCompletionTests : IDisposable Assert.Equal("gpt-3.5-turbo", textContent.ModelId); } + [Fact] + public async Task GetStreamingTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new OpenAIChatCompletionService("model-id", "api-key", "organization", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingTextContentsAsync("Prompt")) + { + Assert.Equal("Test chat streaming response", chunk.Text); + } + } + + [Fact] + public async Task GetStreamingChatMessageContentsWorksCorrectlyAsync() + { + // Arrange + var service = new OpenAIChatCompletionService("model-id", "api-key", "organization", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([])) + { + Assert.Equal("Test chat streaming response", chunk.Content); + } + } + [Fact] public async Task ItAddsSystemMessageAsync() { diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletionWithData/AzureOpenAIChatCompletionWithDataTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletionWithData/AzureOpenAIChatCompletionWithDataTests.cs index 78d30786f8..485e04e3b8 100644 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletionWithData/AzureOpenAIChatCompletionWithDataTests.cs +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ChatCompletionWithData/AzureOpenAIChatCompletionWithDataTests.cs @@ -1,11 +1,14 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.IO; +using System.Net; using System.Net.Http; using System.Text; using System.Threading.Tasks; -using Microsoft.SemanticKernel.ChatCompletion; +using Microsoft.Extensions.Logging; using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; using Xunit; namespace SemanticKernel.Connectors.UnitTests.OpenAI.ChatCompletionWithData; @@ -19,6 +22,7 @@ public sealed class AzureOpenAIChatCompletionWithDataTests : IDisposable private readonly HttpMessageHandlerStub _messageHandlerStub; private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; public AzureOpenAIChatCompletionWithDataTests() { @@ -26,6 +30,22 @@ public sealed class AzureOpenAIChatCompletionWithDataTests : IDisposable this._messageHandlerStub = new HttpMessageHandlerStub(); this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient, this._mockLoggerFactory.Object) : + new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + + // Assert + Assert.NotNull(service); + Assert.Equal("fake-completion-model-id", service.Attributes["ModelId"]); } [Fact] @@ -33,10 +53,10 @@ public sealed class AzureOpenAIChatCompletionWithDataTests : IDisposable { // Arrange const string ExpectedUri = "https://fake-completion-endpoint/openai/deployments/fake-completion-model-id/extensions/chat/completions?api-version=fake-api-version"; - var chatCompletion = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + var service = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); // Act - await chatCompletion.GetChatMessageContentsAsync(new ChatHistory()); + await service.GetChatMessageContentsAsync([]); // Assert var actualUri = this._messageHandlerStub.RequestUri?.AbsoluteUri; @@ -58,10 +78,10 @@ public sealed class AzureOpenAIChatCompletionWithDataTests : IDisposable var config = this.GetConfig(); config.CompletionApiVersion = string.Empty; - var chatCompletion = new AzureOpenAIChatCompletionWithDataService(config, this._httpClient); + var service = new AzureOpenAIChatCompletionWithDataService(config, this._httpClient); // Act - await chatCompletion.GetChatMessageContentsAsync(new ChatHistory()); + await service.GetChatMessageContentsAsync([]); // Assert var actualUri = this._messageHandlerStub.RequestUri?.AbsoluteUri; @@ -69,6 +89,94 @@ public sealed class AzureOpenAIChatCompletionWithDataTests : IDisposable Assert.Contains("2023-06-01-preview", actualUri, StringComparison.OrdinalIgnoreCase); } + [Fact] + public async Task GetChatMessageContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_with_data_test_response.json")) + }; + + // Act + var result = await service.GetChatMessageContentsAsync([]); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat with data response", result[0].Content); + + var usage = result[0].Metadata?["Usage"] as ChatWithDataUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetStreamingChatMessageContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_with_data_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingChatMessageContentsAsync([])) + { + Assert.Equal("Test chat with data streaming response", chunk.Content); + } + } + + [Fact] + public async Task GetTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("chat_completion_with_data_test_response.json")) + }; + + // Act + var result = await service.GetTextContentsAsync("Prompt"); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat with data response", result[0].Text); + + var usage = result[0].Metadata?["Usage"] as ChatWithDataUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetStreamingTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAIChatCompletionWithDataService(this._config, this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("chat_completion_with_data_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingTextContentsAsync("Prompt")) + { + Assert.Equal("Test chat with data streaming response", chunk.Text); + } + } + public void Dispose() { this._httpClient.Dispose(); diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/FunctionCalling/OpenAIFunctionTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/FunctionCalling/OpenAIFunctionTests.cs index 841bde8a32..ea25c66fdf 100644 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/FunctionCalling/OpenAIFunctionTests.cs +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/FunctionCalling/OpenAIFunctionTests.cs @@ -13,6 +13,38 @@ namespace SemanticKernel.Connectors.UnitTests.OpenAI.FunctionCalling; public sealed class OpenAIFunctionTests { + [Theory] + [InlineData(null, null, "", "")] + [InlineData("name", "description", "name", "description")] + public void ItInitializesOpenAIFunctionParameterCorrectly(string? name, string? description, string expectedName, string expectedDescription) + { + // Arrange & Act + var schema = KernelJsonSchema.Parse("{\"type\": \"object\" }"); + var functionParameter = new OpenAIFunctionParameter(name, description, true, typeof(string), schema); + + // Assert + Assert.Equal(expectedName, functionParameter.Name); + Assert.Equal(expectedDescription, functionParameter.Description); + Assert.True(functionParameter.IsRequired); + Assert.Equal(typeof(string), functionParameter.ParameterType); + Assert.Same(schema, functionParameter.Schema); + } + + [Theory] + [InlineData(null, "")] + [InlineData("description", "description")] + public void ItInitializesOpenAIFunctionReturnParameterCorrectly(string? description, string expectedDescription) + { + // Arrange & Act + var schema = KernelJsonSchema.Parse("{\"type\": \"object\" }"); + var functionParameter = new OpenAIFunctionReturnParameter(description, typeof(string), schema); + + // Assert + Assert.Equal(expectedDescription, functionParameter.Description); + Assert.Equal(typeof(string), functionParameter.ParameterType); + Assert.Same(schema, functionParameter.Schema); + } + [Fact] public void ItCanConvertToFunctionDefinitionWithNoPluginName() { @@ -27,6 +59,19 @@ public sealed class OpenAIFunctionTests Assert.Equal(sut.Description, result.Description); } + [Fact] + public void ItCanConvertToFunctionDefinitionWithNullParameters() + { + // Arrange + OpenAIFunction sut = new("plugin", "function", "description", null, null); + + // Act + var result = sut.ToFunctionDefinition(); + + // Assert + Assert.Equal("{\"type\":\"object\",\"required\":[],\"properties\":{}}", result.Parameters.ToString()); + } + [Fact] public void ItCanConvertToFunctionDefinitionWithPluginName() { diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIMemoryBuilderExtensionsTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIMemoryBuilderExtensionsTests.cs new file mode 100644 index 0000000000..08bde153aa --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIMemoryBuilderExtensionsTests.cs @@ -0,0 +1,66 @@ +// Copyright (c) Microsoft. All rights reserved. + +using Azure.Core; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Microsoft.SemanticKernel.Memory; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIMemoryBuilderExtensionsTests +{ + private readonly Mock _mockMemoryStore = new(); + + [Fact] + public void AzureOpenAITextEmbeddingGenerationWithApiKeyWorksCorrectly() + { + // Arrange + var builder = new MemoryBuilder(); + + // Act + var memory = builder + .WithAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", "api-key", "model-id") + .WithMemoryStore(this._mockMemoryStore.Object) + .Build(); + + // Assert + Assert.NotNull(memory); + } + + [Fact] + public void AzureOpenAITextEmbeddingGenerationWithTokenCredentialWorksCorrectly() + { + // Arrange + var builder = new MemoryBuilder(); + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + + // Act + var memory = builder + .WithAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", credentials, "model-id") + .WithMemoryStore(this._mockMemoryStore.Object) + .Build(); + + // Assert + Assert.NotNull(memory); + } + + [Fact] + public void OpenAITextEmbeddingGenerationWithApiKeyWorksCorrectly() + { + // Arrange + var builder = new MemoryBuilder(); + + // Act + var memory = builder + .WithOpenAITextEmbeddingGeneration("model-id", "api-key", "organization-id") + .WithMemoryStore(this._mockMemoryStore.Object) + .Build(); + + // Assert + Assert.NotNull(memory); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIPromptExecutionSettingsTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIPromptExecutionSettingsTests.cs index b4753312eb..1cdee512ad 100644 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIPromptExecutionSettingsTests.cs +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIPromptExecutionSettingsTests.cs @@ -158,6 +158,18 @@ public class OpenAIPromptExecutionSettingsTests AssertExecutionSettings(executionSettings); } + [Theory] + [InlineData("", "Assistant is a large language model.")] + [InlineData("System prompt", "System prompt")] + public void ItUsesCorrectChatSystemPrompt(string chatSystemPrompt, string expectedChatSystemPrompt) + { + // Arrange & Act + var settings = new OpenAIPromptExecutionSettings { ChatSystemPrompt = chatSystemPrompt }; + + // Assert + Assert.Equal(expectedChatSystemPrompt, settings.ChatSystemPrompt); + } + private static void AssertExecutionSettings(OpenAIPromptExecutionSettings executionSettings) { Assert.NotNull(executionSettings); diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIServiceCollectionExtensionsTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIServiceCollectionExtensionsTests.cs new file mode 100644 index 0000000000..0d263e9365 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/OpenAIServiceCollectionExtensionsTests.cs @@ -0,0 +1,497 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Net.Http; +using Azure.AI.OpenAI; +using Azure.Core; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.ChatCompletion; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Microsoft.SemanticKernel.Embeddings; +using Microsoft.SemanticKernel.TextGeneration; +using Microsoft.SemanticKernel.TextToImage; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI; + +/// +/// Unit tests for class. +/// +public sealed class OpenAIServiceCollectionExtensionsTests : IDisposable +{ + private readonly HttpClient _httpClient; + + public OpenAIServiceCollectionExtensionsTests() + { + this._httpClient = new HttpClient(); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void KernelBuilderAddAzureOpenAITextGenerationAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddAzureOpenAITextGeneration("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.AddAzureOpenAITextGeneration("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.AddAzureOpenAITextGeneration("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddAzureOpenAITextGeneration("deployment-name"), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void ServiceCollectionAddAzureOpenAITextGenerationAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddAzureOpenAITextGeneration("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.Services.AddAzureOpenAITextGeneration("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.Services.AddAzureOpenAITextGeneration("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddAzureOpenAITextGeneration("deployment-name"), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void KernelBuilderAddOpenAITextGenerationAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddOpenAITextGeneration("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.AddOpenAITextGeneration("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddOpenAITextGeneration("model-id"), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void ServiceCollectionAddOpenAITextGenerationAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddOpenAITextGeneration("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.Services.AddOpenAITextGeneration("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddOpenAITextGeneration("model-id"), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void KernelBuilderAddAzureOpenAITextEmbeddingGenerationAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.AddAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.AddAzureOpenAITextEmbeddingGeneration("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddAzureOpenAITextEmbeddingGeneration("deployment-name"), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextEmbeddingGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void ServiceCollectionAddAzureOpenAITextEmbeddingGenerationAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.Services.AddAzureOpenAITextEmbeddingGeneration("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.Services.AddAzureOpenAITextEmbeddingGeneration("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddAzureOpenAITextEmbeddingGeneration("deployment-name"), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextEmbeddingGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void KernelBuilderAddOpenAITextEmbeddingGenerationAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddOpenAITextEmbeddingGeneration("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.AddOpenAITextEmbeddingGeneration("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddOpenAITextEmbeddingGeneration("model-id"), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextEmbeddingGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void ServiceCollectionAddOpenAITextEmbeddingGenerationAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddOpenAITextEmbeddingGeneration("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.Services.AddOpenAITextEmbeddingGeneration("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddOpenAITextEmbeddingGeneration("model-id"), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextEmbeddingGenerationService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + [InlineData(InitializationType.ChatCompletionWithData)] + public void KernelBuilderAddAzureOpenAIChatCompletionAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var config = this.GetCompletionWithDataConfig(); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddAzureOpenAIChatCompletion("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.AddAzureOpenAIChatCompletion("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.AddAzureOpenAIChatCompletion("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddAzureOpenAIChatCompletion("deployment-name"), + InitializationType.ChatCompletionWithData => builder.AddAzureOpenAIChatCompletion(config), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + + if (type == InitializationType.ChatCompletionWithData) + { + Assert.True(service is AzureOpenAIChatCompletionWithDataService); + } + else + { + Assert.True(service is AzureOpenAIChatCompletionService); + } + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.TokenCredential)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + [InlineData(InitializationType.ChatCompletionWithData)] + public void ServiceCollectionAddAzureOpenAIChatCompletionAddsValidService(InitializationType type) + { + // Arrange + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var client = new OpenAIClient("key"); + var config = this.GetCompletionWithDataConfig(); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddAzureOpenAIChatCompletion("deployment-name", "https://endpoint", "api-key"), + InitializationType.TokenCredential => builder.Services.AddAzureOpenAIChatCompletion("deployment-name", "https://endpoint", credentials), + InitializationType.OpenAIClientInline => builder.Services.AddAzureOpenAIChatCompletion("deployment-name", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddAzureOpenAIChatCompletion("deployment-name"), + InitializationType.ChatCompletionWithData => builder.Services.AddAzureOpenAIChatCompletion(config), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + + if (type == InitializationType.ChatCompletionWithData) + { + Assert.True(service is AzureOpenAIChatCompletionWithDataService); + } + else + { + Assert.True(service is AzureOpenAIChatCompletionService); + } + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void KernelBuilderAddOpenAIChatCompletionAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + builder = type switch + { + InitializationType.ApiKey => builder.AddOpenAIChatCompletion("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.AddOpenAIChatCompletion("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.AddOpenAIChatCompletion("model-id"), + _ => builder + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAIChatCompletionService); + } + + [Theory] + [InlineData(InitializationType.ApiKey)] + [InlineData(InitializationType.OpenAIClientInline)] + [InlineData(InitializationType.OpenAIClientInServiceProvider)] + public void ServiceCollectionAddOpenAIChatCompletionAddsValidService(InitializationType type) + { + // Arrange + var client = new OpenAIClient("key"); + var builder = Kernel.CreateBuilder(); + + builder.Services.AddSingleton(client); + + // Act + IServiceCollection collection = type switch + { + InitializationType.ApiKey => builder.Services.AddOpenAIChatCompletion("model-id", "api-key"), + InitializationType.OpenAIClientInline => builder.Services.AddOpenAIChatCompletion("model-id", client), + InitializationType.OpenAIClientInServiceProvider => builder.Services.AddOpenAIChatCompletion("model-id"), + _ => builder.Services + }; + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAIChatCompletionService); + } + + [Fact] + public void KernelBuilderAddAzureOpenAITextToImageAddsValidService() + { + // Arrange + var builder = Kernel.CreateBuilder(); + + // Act + builder = builder.AddAzureOpenAITextToImage("deployment-name", "https://endpoint", "api-key"); + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextToImageService); + } + + [Fact] + public void ServiceCollectionAddAzureOpenAITextToImageAddsValidService() + { + // Arrange + var builder = Kernel.CreateBuilder(); + + // Act + builder.Services.AddAzureOpenAITextToImage("deployment-name", "https://endpoint", "api-key"); + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is AzureOpenAITextToImageService); + } + + [Fact] + public void KernelBuilderAddOpenAITextToImageAddsValidService() + { + // Arrange + var builder = Kernel.CreateBuilder(); + + // Act + builder = builder.AddOpenAITextToImage("model-id", "api-key"); + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextToImageService); + } + + [Fact] + public void ServiceCollectionAddOpenAITextToImageAddsValidService() + { + // Arrange + var builder = Kernel.CreateBuilder(); + + // Act + builder.Services.AddOpenAITextToImage("model-id", "api-key"); + + // Assert + var service = builder.Build().GetRequiredService(); + + Assert.NotNull(service); + Assert.True(service is OpenAITextToImageService); + } + + public void Dispose() + { + this._httpClient.Dispose(); + } + + public enum InitializationType + { + ApiKey, + TokenCredential, + OpenAIClientInline, + OpenAIClientInServiceProvider, + ChatCompletionWithData + } + + private AzureOpenAIChatCompletionWithDataConfig GetCompletionWithDataConfig() + { + return new() + { + CompletionApiKey = "completion-api-key", + CompletionApiVersion = "completion-v1", + CompletionEndpoint = "https://completion-endpoint", + CompletionModelId = "completion-model-id", + DataSourceApiKey = "data-source-api-key", + DataSourceEndpoint = "https://data-source-endpoint", + DataSourceIndex = "data-source-index" + }; + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_multiple_function_calls_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_multiple_function_calls_test_response.json new file mode 100644 index 0000000000..9761696b43 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_multiple_function_calls_test_response.json @@ -0,0 +1,56 @@ +{ + "id": "response-id", + "object": "chat.completion", + "created": 1699896916, + "model": "gpt-3.5-turbo-0613", + "choices": [ + { + "index": 0, + "message": { + "role": "assistant", + "content": null, + "tool_calls": [ + { + "id": "1", + "type": "function", + "function": { + "name": "MyPlugin_GetCurrentWeather", + "arguments": "{\n\"location\": \"Boston, MA\"\n}" + } + }, + { + "id": "2", + "type": "function", + "function": { + "name": "MyPlugin_FunctionWithException", + "arguments": "{\n\"argument\": \"value\"\n}" + } + }, + { + "id": "3", + "type": "function", + "function": { + "name": "MyPlugin_NonExistentFunction", + "arguments": "{\n\"argument\": \"value\"\n}" + } + }, + { + "id": "4", + "type": "function", + "function": { + "name": "MyPlugin_InvalidArguments", + "arguments": "invalid_arguments_format" + } + } + ] + }, + "logprobs": null, + "finish_reason": "tool_calls" + } + ], + "usage": { + "prompt_tokens": 82, + "completion_tokens": 17, + "total_tokens": 99 + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_single_function_call_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_single_function_call_test_response.json new file mode 100644 index 0000000000..4712f85226 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_single_function_call_test_response.json @@ -0,0 +1,32 @@ +{ + "id": "response-id", + "object": "chat.completion", + "created": 1699896916, + "model": "gpt-3.5-turbo-0613", + "choices": [ + { + "index": 0, + "message": { + "role": "assistant", + "content": null, + "tool_calls": [ + { + "id": "1", + "type": "function", + "function": { + "name": "MyPlugin_GetCurrentWeather", + "arguments": "{\n\"location\": \"Boston, MA\"\n}" + } + } + ] + }, + "logprobs": null, + "finish_reason": "tool_calls" + } + ], + "usage": { + "prompt_tokens": 82, + "completion_tokens": 17, + "total_tokens": 99 + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_multiple_function_calls_test_response.txt b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_multiple_function_calls_test_response.txt new file mode 100644 index 0000000000..17ce94647f --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_multiple_function_calls_test_response.txt @@ -0,0 +1,9 @@ +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":"Test chat streaming response","tool_calls":[{"index":0,"id":"1","type":"function","function":{"name":"MyPlugin_GetCurrentWeather","arguments":"{\n\"location\": \"Boston, MA\"\n}"}}]},"finish_reason":"tool_calls"}]} + +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":"Test chat streaming response","tool_calls":[{"index":1,"id":"2","type":"function","function":{"name":"MyPlugin_FunctionWithException","arguments":"{\n\"argument\": \"value\"\n}"}}]},"finish_reason":"tool_calls"}]} + +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":"Test chat streaming response","tool_calls":[{"index":2,"id":"3","type":"function","function":{"name":"MyPlugin_NonExistentFunction","arguments":"{\n\"argument\": \"value\"\n}"}}]},"finish_reason":"tool_calls"}]} + +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":"Test chat streaming response","tool_calls":[{"index":3,"id":"4","type":"function","function":{"name":"MyPlugin_InvalidArguments","arguments":"invalid_arguments_format"}}]},"finish_reason":"tool_calls"}]} + +data: [DONE] diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_single_function_call_test_response.txt b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_single_function_call_test_response.txt new file mode 100644 index 0000000000..ee4d5894e6 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_single_function_call_test_response.txt @@ -0,0 +1,3 @@ +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"role":"assistant","content":"Test chat streaming response","tool_calls":[{"index":0,"id":"1","type":"function","function":{"name":"MyPlugin_GetCurrentWeather","arguments":"{\n\"location\": \"Boston, MA\"\n}"}}]},"finish_reason":"tool_calls"}]} + +data: [DONE] diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_test_response.txt b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_test_response.txt new file mode 100644 index 0000000000..8301463c60 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_streaming_test_response.txt @@ -0,0 +1,3 @@ +data: {"id":"response-id","object":"chat.completion.chunk","created":1704212243,"model":"gpt-4","system_fingerprint":null,"choices":[{"index":0,"delta":{"content":"Test chat streaming response"},"finish_reason":null}]} + +data: [DONE] diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_test_response.json new file mode 100644 index 0000000000..b601bac8b5 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_test_response.json @@ -0,0 +1,22 @@ +{ + "id": "response-id", + "object": "chat.completion", + "created": 1704208954, + "model": "gpt-4", + "choices": [ + { + "index": 0, + "message": { + "role": "assistant", + "content": "Test chat response" + }, + "finish_reason": "stop" + } + ], + "usage": { + "prompt_tokens": 55, + "completion_tokens": 100, + "total_tokens": 155 + }, + "system_fingerprint": null +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_streaming_test_response.txt b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_streaming_test_response.txt new file mode 100644 index 0000000000..5e17403da9 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_streaming_test_response.txt @@ -0,0 +1 @@ +data: {"id":"response-id","model":"","created":1684304924,"object":"chat.completion","choices":[{"index":0,"messages":[{"delta":{"role":"assistant","content":"Test chat with data streaming response"},"end_turn":false}]}]} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_test_response.json new file mode 100644 index 0000000000..40d769dac8 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/chat_completion_with_data_test_response.json @@ -0,0 +1,28 @@ +{ + "id": "response-id", + "model": "", + "created": 1684304924, + "object": "chat.completion", + "choices": [ + { + "index": 0, + "messages": [ + { + "role": "tool", + "content": "{\"citations\": [{\"content\": \"\\nAzure AI services are cloud-based artificial intelligence (AI) services...\", \"id\": null, \"title\": \"What is Azure AI services\", \"filepath\": null, \"url\": null, \"metadata\": {\"chunking\": \"original document size=250. Scores=0.4314117431640625 and 1.72564697265625.Org Highlight count=4.\"}, \"chunk_id\": \"0\"}], \"intent\": \"[\\\"Learn about Azure AI services.\\\"]\"}", + "end_turn": false + }, + { + "role": "assistant", + "content": "Test chat with data response", + "end_turn": true + } + ] + } + ], + "usage": { + "prompt_tokens": 55, + "completion_tokens": 100, + "total_tokens": 155 + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_generation_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_generation_test_response.json deleted file mode 100644 index 87b9ab7d7c..0000000000 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_generation_test_response.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "id": "32ba9f77-d620-4b6c-9265-ad50cb314a5c", - "status": "notRunning" -} \ No newline at end of file diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_result_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_result_test_response.json deleted file mode 100644 index 61904f1b0a..0000000000 --- a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/image_result_test_response.json +++ /dev/null @@ -1,12 +0,0 @@ -{ - "created": 1686192127, - "expires": 1686278532, - "id": "32ba9f77-d620-4b6c-9265-ad50cb314a5c", - "result": { - "created": 1686192127, - "data": [ - { "url": "https://dalleproduse.blob.core.windows.net/private/images/generated_00.png" } - ] - }, - "status": "succeeded" -} \ No newline at end of file diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_streaming_test_response.txt b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_streaming_test_response.txt new file mode 100644 index 0000000000..a511ea4462 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_streaming_test_response.txt @@ -0,0 +1,3 @@ +data: {"id":"response-id","object":"text_completion","created":1646932609,"model":"ada","choices":[{"text":"Test chat streaming response","index":0,"logprobs":null,"finish_reason":"length"}],"usage":{"prompt_tokens":55,"completion_tokens":100,"total_tokens":155}} + +data: [DONE] diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_test_response.json b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_test_response.json new file mode 100644 index 0000000000..5402294374 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TestData/text_completion_test_response.json @@ -0,0 +1,19 @@ +{ + "id": "response-id", + "object": "text_completion", + "created": 1646932609, + "model": "ada", + "choices": [ + { + "text": "Test chat response", + "index": 0, + "logprobs": null, + "finish_reason": "length" + } + ], + "usage": { + "prompt_tokens": 55, + "completion_tokens": 100, + "total_tokens": 155 + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationServiceTests.cs new file mode 100644 index 0000000000..210845c219 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/AzureOpenAITextEmbeddingGenerationServiceTests.cs @@ -0,0 +1,152 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Azure.Core; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.TextEmbedding; + +/// +/// Unit tests for class. +/// +public sealed class AzureOpenAITextEmbeddingGenerationServiceTests : IDisposable +{ + private readonly HttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public AzureOpenAITextEmbeddingGenerationServiceTests() + { + this._messageHandlerStub = new HttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new AzureOpenAITextEmbeddingGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextEmbeddingGenerationService("deployment-name", "https://endpoint", "api-key", "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithTokenCredentialWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var service = includeLoggerFactory ? + new AzureOpenAITextEmbeddingGenerationService("deployment", "https://endpoint", credentials, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextEmbeddingGenerationService("deployment", "https://endpoint", credentials, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new AzureOpenAITextEmbeddingGenerationService("deployment", client, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextEmbeddingGenerationService("deployment", client, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Fact] + public async Task GenerateEmbeddingsForEmptyDataReturnsEmptyResultAsync() + { + // Arrange + var service = new AzureOpenAITextEmbeddingGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + + // Act + var result = await service.GenerateEmbeddingsAsync([]); + + // Assert + Assert.Empty(result); + } + + [Fact] + public async Task GenerateEmbeddingsWithEmptyResponseThrowsExceptionAsync() + { + // Arrange + var service = new AzureOpenAITextEmbeddingGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.OK) + { + Content = new StringContent(@"{ + ""object"": ""list"", + ""data"": [], + ""model"": ""model-id"" + }", Encoding.UTF8, "application/json") + }; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GenerateEmbeddingsAsync(["test"])); + Assert.Equal("Text embedding not found", exception.Message); + } + + [Fact] + public async Task GenerateEmbeddingsByDefaultWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAITextEmbeddingGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.OK) + { + Content = new StringContent(@"{ + ""object"": ""list"", + ""data"": [ + { + ""object"": ""embedding"", + ""embedding"": [ + 0.018990106880664825, + -0.0073809814639389515 + ], + ""index"": 0 + } + ], + ""model"": ""model-id"" + }", Encoding.UTF8, "application/json") + }; + + // Act + var result = await service.GenerateEmbeddingsAsync(["test"]); + + // Assert + Assert.Single(result); + + var memory = result[0]; + + Assert.Equal(0.018990106880664825, memory.Span[0]); + Assert.Equal(-0.0073809814639389515, memory.Span[1]); + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/OpenAITextEmbeddingGenerationServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/OpenAITextEmbeddingGenerationServiceTests.cs new file mode 100644 index 0000000000..bb9ff5fd42 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextEmbedding/OpenAITextEmbeddingGenerationServiceTests.cs @@ -0,0 +1,135 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.TextEmbedding; + +/// +/// Unit tests for class. +/// +public sealed class OpenAITextEmbeddingGenerationServiceTests : IDisposable +{ + private readonly HttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public OpenAITextEmbeddingGenerationServiceTests() + { + this._messageHandlerStub = new HttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new OpenAITextEmbeddingGenerationService("model-id", "api-key", "organization", loggerFactory: this._mockLoggerFactory.Object) : + new OpenAITextEmbeddingGenerationService("model-id", "api-key", "organization"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new OpenAITextEmbeddingGenerationService("model-id", client, loggerFactory: this._mockLoggerFactory.Object) : + new OpenAITextEmbeddingGenerationService("model-id", client); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Fact] + public async Task GenerateEmbeddingsForEmptyDataReturnsEmptyResultAsync() + { + // Arrange + var service = new OpenAITextEmbeddingGenerationService("model-id", "api-key", "organization", this._httpClient); + + // Act + var result = await service.GenerateEmbeddingsAsync([]); + + // Assert + Assert.Empty(result); + } + + [Fact] + public async Task GenerateEmbeddingsWithEmptyResponseThrowsExceptionAsync() + { + // Arrange + var service = new OpenAITextEmbeddingGenerationService("model-id", "api-key", "organization", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.OK) + { + Content = new StringContent(@"{ + ""object"": ""list"", + ""data"": [], + ""model"": ""model-id"" + }", Encoding.UTF8, "application/json") + }; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GenerateEmbeddingsAsync(["test"])); + Assert.Equal("Text embedding not found", exception.Message); + } + + [Fact] + public async Task GenerateEmbeddingsByDefaultWorksCorrectlyAsync() + { + // Arrange + var service = new OpenAITextEmbeddingGenerationService("model-id", "api-key", "organization", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.OK) + { + Content = new StringContent(@"{ + ""object"": ""list"", + ""data"": [ + { + ""object"": ""embedding"", + ""embedding"": [ + 0.018990106880664825, + -0.0073809814639389515 + ], + ""index"": 0 + } + ], + ""model"": ""model-id"" + }", Encoding.UTF8, "application/json") + }; + + // Act + var result = await service.GenerateEmbeddingsAsync(["test"]); + + // Assert + Assert.Single(result); + + var memory = result[0]; + + Assert.Equal(0.018990106880664825, memory.Span[0]); + Assert.Equal(-0.0073809814639389515, memory.Span[1]); + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/AzureOpenAITextGenerationServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/AzureOpenAITextGenerationServiceTests.cs new file mode 100644 index 0000000000..87f5526d5f --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/AzureOpenAITextGenerationServiceTests.cs @@ -0,0 +1,208 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.IO; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Text.Json; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Azure.Core; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.TextGeneration; + +/// +/// Unit tests for class. +/// +public sealed class AzureOpenAITextGenerationServiceTests : IDisposable +{ + private readonly HttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public AzureOpenAITextGenerationServiceTests() + { + this._messageHandlerStub = new HttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithTokenCredentialWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var credentials = DelegatedTokenCredential.Create((_, _) => new AccessToken()); + var service = includeLoggerFactory ? + new AzureOpenAITextGenerationService("deployment", "https://endpoint", credentials, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextGenerationService("deployment", "https://endpoint", credentials, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new AzureOpenAITextGenerationService("deployment", client, "model-id", loggerFactory: this._mockLoggerFactory.Object) : + new AzureOpenAITextGenerationService("deployment", client, "model-id"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Fact] + public async Task GetTextContentsWithEmptyChoicesThrowsExceptionAsync() + { + // Arrange + var service = new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent("{\"id\":\"response-id\",\"object\":\"text_completion\",\"created\":1646932609,\"model\":\"ada\",\"choices\":[]}") + }; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GetTextContentsAsync("Prompt")); + + Assert.Equal("Text completions not found", exception.Message); + } + + [Theory] + [InlineData(0)] + [InlineData(129)] + public async Task GetTextContentsWithInvalidResultsPerPromptValueThrowsExceptionAsync(int resultsPerPrompt) + { + // Arrange + var service = new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings { ResultsPerPrompt = resultsPerPrompt }; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => service.GetTextContentsAsync("Prompt", settings)); + + Assert.Contains("The value must be in range between", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task GetTextContentsHandlesSettingsCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + var settings = new OpenAIPromptExecutionSettings + { + MaxTokens = 123, + Temperature = 0.6, + TopP = 0.5, + FrequencyPenalty = 1.6, + PresencePenalty = 1.2, + ResultsPerPrompt = 5, + TokenSelectionBiases = new Dictionary { { 2, 3 } }, + StopSequences = ["stop_sequence"] + }; + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("text_completion_test_response.json")) + }; + + // Act + var result = await service.GetTextContentsAsync("Prompt", settings); + + // Assert + var requestContent = this._messageHandlerStub.RequestContent; + + Assert.NotNull(requestContent); + + var content = JsonSerializer.Deserialize(Encoding.UTF8.GetString(requestContent)); + + Assert.Equal("Prompt", content.GetProperty("prompt")[0].GetString()); + Assert.Equal(123, content.GetProperty("max_tokens").GetInt32()); + Assert.Equal(0.6, content.GetProperty("temperature").GetDouble()); + Assert.Equal(0.5, content.GetProperty("top_p").GetDouble()); + Assert.Equal(1.6, content.GetProperty("frequency_penalty").GetDouble()); + Assert.Equal(1.2, content.GetProperty("presence_penalty").GetDouble()); + Assert.Equal(5, content.GetProperty("n").GetInt32()); + Assert.Equal(5, content.GetProperty("best_of").GetInt32()); + Assert.Equal(3, content.GetProperty("logit_bias").GetProperty("2").GetInt32()); + Assert.Equal("stop_sequence", content.GetProperty("stop")[0].GetString()); + } + + [Fact] + public async Task GetTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("text_completion_test_response.json")) + }; + + // Act + var result = await service.GetTextContentsAsync("Prompt"); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat response", result[0].Text); + + var usage = result[0].Metadata?["Usage"] as CompletionsUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetStreamingTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new AzureOpenAITextGenerationService("deployment-name", "https://endpoint", "api-key", "model-id", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("text_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingTextContentsAsync("Prompt")) + { + Assert.Equal("Test chat streaming response", chunk.Text); + } + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/OpenAITextGenerationServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/OpenAITextGenerationServiceTests.cs new file mode 100644 index 0000000000..b8d804c21b --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextGeneration/OpenAITextGenerationServiceTests.cs @@ -0,0 +1,113 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.IO; +using System.Net; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using Azure.AI.OpenAI; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.TextGeneration; + +/// +/// Unit tests for class. +/// +public sealed class OpenAITextGenerationServiceTests : IDisposable +{ + private readonly HttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public OpenAITextGenerationServiceTests() + { + this._messageHandlerStub = new HttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithApiKeyWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new OpenAITextGenerationService("model-id", "api-key", "organization", loggerFactory: this._mockLoggerFactory.Object) : + new OpenAITextGenerationService("model-id", "api-key", "organization"); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWithOpenAIClientWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var client = new OpenAIClient("key"); + var service = includeLoggerFactory ? + new OpenAITextGenerationService("model-id", client, loggerFactory: this._mockLoggerFactory.Object) : + new OpenAITextGenerationService("model-id", client); + + // Assert + Assert.NotNull(service); + Assert.Equal("model-id", service.Attributes["ModelId"]); + } + + [Fact] + public async Task GetTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new OpenAITextGenerationService("model-id", "api-key", "organization", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StringContent(OpenAITestHelper.GetTestResponse("text_completion_test_response.json")) + }; + + // Act + var result = await service.GetTextContentsAsync("Prompt"); + + // Assert + Assert.True(result.Count > 0); + Assert.Equal("Test chat response", result[0].Text); + + var usage = result[0].Metadata?["Usage"] as CompletionsUsage; + + Assert.NotNull(usage); + Assert.Equal(55, usage.PromptTokens); + Assert.Equal(100, usage.CompletionTokens); + Assert.Equal(155, usage.TotalTokens); + } + + [Fact] + public async Task GetStreamingTextContentsWorksCorrectlyAsync() + { + // Arrange + var service = new OpenAITextGenerationService("model-id", "api-key", "organization", this._httpClient); + using var stream = new MemoryStream(Encoding.UTF8.GetBytes(OpenAITestHelper.GetTestResponse("text_completion_streaming_test_response.txt"))); + + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(HttpStatusCode.OK) + { + Content = new StreamContent(stream) + }; + + // Act & Assert + await foreach (var chunk in service.GetStreamingTextContentsAsync("Prompt")) + { + Assert.Equal("Test chat streaming response", chunk.Text); + } + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextToImage/OpenAITextToImageServiceTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextToImage/OpenAITextToImageServiceTests.cs new file mode 100644 index 0000000000..a420a187d7 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/TextToImage/OpenAITextToImageServiceTests.cs @@ -0,0 +1,85 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Net.Http; +using System.Text; +using System.Threading.Tasks; +using Microsoft.Extensions.Logging; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Moq; +using Xunit; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI.TextToImage; + +/// +/// Unit tests for class. +/// +public sealed class OpenAITextToImageServiceTests : IDisposable +{ + private readonly HttpMessageHandlerStub _messageHandlerStub; + private readonly HttpClient _httpClient; + private readonly Mock _mockLoggerFactory; + + public OpenAITextToImageServiceTests() + { + this._messageHandlerStub = new HttpMessageHandlerStub(); + this._httpClient = new HttpClient(this._messageHandlerStub, false); + this._mockLoggerFactory = new Mock(); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ConstructorWorksCorrectly(bool includeLoggerFactory) + { + // Arrange & Act + var service = includeLoggerFactory ? + new OpenAITextToImageService("api-key", "organization", loggerFactory: this._mockLoggerFactory.Object) : + new OpenAITextToImageService("api-key", "organization"); + + // Assert + Assert.NotNull(service); + Assert.Equal("organization", service.Attributes["Organization"]); + } + + [Theory] + [InlineData(123, 456, true)] + [InlineData(256, 512, true)] + [InlineData(256, 256, false)] + [InlineData(512, 512, false)] + [InlineData(1024, 1024, false)] + public async Task GenerateImageWorksCorrectlyAsync(int width, int height, bool expectedException) + { + // Arrange + var service = new OpenAITextToImageService("api-key", "organization", this._httpClient); + this._messageHandlerStub.ResponseToReturn = new HttpResponseMessage(System.Net.HttpStatusCode.OK) + { + Content = new StringContent(@"{ + ""created"": 1702575371, + ""data"": [ + { + ""url"": ""https://image-url"" + } + ] + }", Encoding.UTF8, "application/json") + }; + + // Act & Assert + if (expectedException) + { + await Assert.ThrowsAsync(() => service.GenerateImageAsync("description", width, height)); + } + else + { + var result = await service.GenerateImageAsync("description", width, height); + + Assert.Equal("https://image-url", result); + } + } + + public void Dispose() + { + this._httpClient.Dispose(); + this._messageHandlerStub.Dispose(); + } +} diff --git a/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ToolCallBehaviorTests.cs b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ToolCallBehaviorTests.cs new file mode 100644 index 0000000000..ce04b69003 --- /dev/null +++ b/dotnet/src/Connectors/Connectors.UnitTests/OpenAI/ToolCallBehaviorTests.cs @@ -0,0 +1,218 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System.Collections.Generic; +using System.Linq; +using Azure.AI.OpenAI; +using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.Connectors.OpenAI; +using Xunit; +using static Microsoft.SemanticKernel.Connectors.OpenAI.ToolCallBehavior; + +namespace SemanticKernel.Connectors.UnitTests.OpenAI; + +/// +/// Unit tests for +/// +public sealed class ToolCallBehaviorTests +{ + [Fact] + public void EnableKernelFunctionsReturnsCorrectKernelFunctionsInstance() + { + // Arrange & Act + var behavior = ToolCallBehavior.EnableKernelFunctions; + + // Assert + Assert.IsType(behavior); + Assert.Equal(0, behavior.MaximumAutoInvokeAttempts); + } + + [Fact] + public void AutoInvokeKernelFunctionsReturnsCorrectKernelFunctionsInstance() + { + // Arrange & Act + var behavior = ToolCallBehavior.AutoInvokeKernelFunctions; + + // Assert + Assert.IsType(behavior); + Assert.Equal(5, behavior.MaximumAutoInvokeAttempts); + } + + [Fact] + public void EnableFunctionsReturnsEnabledFunctionsInstance() + { + // Arrange & Act + List functions = [new("Plugin", "Function", "description", [], null)]; + var behavior = ToolCallBehavior.EnableFunctions(functions); + + // Assert + Assert.IsType(behavior); + } + + [Fact] + public void RequireFunctionReturnsRequiredFunctionInstance() + { + // Arrange & Act + var behavior = ToolCallBehavior.RequireFunction(new("Plugin", "Function", "description", [], null)); + + // Assert + Assert.IsType(behavior); + } + + [Fact] + public void KernelFunctionsConfigureOptionsWithNullKernelDoesNotAddTools() + { + // Arrange + var kernelFunctions = new KernelFunctions(autoInvoke: false); + var chatCompletionsOptions = new ChatCompletionsOptions(); + + // Act + kernelFunctions.ConfigureOptions(null, chatCompletionsOptions); + + // Assert + Assert.Empty(chatCompletionsOptions.Tools); + } + + [Fact] + public void KernelFunctionsConfigureOptionsWithoutFunctionsDoesNotAddTools() + { + // Arrange + var kernelFunctions = new KernelFunctions(autoInvoke: false); + var chatCompletionsOptions = new ChatCompletionsOptions(); + var kernel = Kernel.CreateBuilder().Build(); + + // Act + kernelFunctions.ConfigureOptions(kernel, chatCompletionsOptions); + + // Assert + Assert.Null(chatCompletionsOptions.ToolChoice); + Assert.Empty(chatCompletionsOptions.Tools); + } + + [Fact] + public void KernelFunctionsConfigureOptionsWithFunctionsAddsTools() + { + // Arrange + var kernelFunctions = new KernelFunctions(autoInvoke: false); + var chatCompletionsOptions = new ChatCompletionsOptions(); + var kernel = Kernel.CreateBuilder().Build(); + + var plugin = this.GetTestPlugin(); + + kernel.Plugins.Add(plugin); + + // Act + kernelFunctions.ConfigureOptions(kernel, chatCompletionsOptions); + + // Assert + Assert.Equal(ChatCompletionsToolChoice.Auto, chatCompletionsOptions.ToolChoice); + + this.AssertTools(chatCompletionsOptions); + } + + [Fact] + public void EnabledFunctionsConfigureOptionsWithoutFunctionsDoesNotAddTools() + { + // Arrange + var enabledFunctions = new EnabledFunctions([], autoInvoke: false); + var chatCompletionsOptions = new ChatCompletionsOptions(); + + // Act + enabledFunctions.ConfigureOptions(null, chatCompletionsOptions); + + // Assert + Assert.Null(chatCompletionsOptions.ToolChoice); + Assert.Empty(chatCompletionsOptions.Tools); + } + + [Fact] + public void EnabledFunctionsConfigureOptionsWithAutoInvokeAndNullKernelThrowsException() + { + // Arrange + var functions = this.GetTestPlugin().GetFunctionsMetadata().Select(function => function.ToOpenAIFunction()); + var enabledFunctions = new EnabledFunctions(functions, autoInvoke: true); + var chatCompletionsOptions = new ChatCompletionsOptions(); + + // Act & Assert + var exception = Assert.Throws(() => enabledFunctions.ConfigureOptions(null, chatCompletionsOptions)); + Assert.Equal($"Auto-invocation with {nameof(EnabledFunctions)} is not supported when no kernel is provided.", exception.Message); + } + + [Fact] + public void EnabledFunctionsConfigureOptionsWithAutoInvokeAndEmptyKernelThrowsException() + { + // Arrange + var functions = this.GetTestPlugin().GetFunctionsMetadata().Select(function => function.ToOpenAIFunction()); + var enabledFunctions = new EnabledFunctions(functions, autoInvoke: true); + var chatCompletionsOptions = new ChatCompletionsOptions(); + var kernel = Kernel.CreateBuilder().Build(); + + // Act & Assert + var exception = Assert.Throws(() => enabledFunctions.ConfigureOptions(kernel, chatCompletionsOptions)); + Assert.Equal($"The specified {nameof(EnabledFunctions)} function MyPlugin_MyFunction is not available in the kernel.", exception.Message); + } + + [Theory] + [InlineData(true)] + [InlineData(false)] + public void EnabledFunctionsConfigureOptionsWithKernelAndPluginsAddsTools(bool autoInvoke) + { + // Arrange + var plugin = this.GetTestPlugin(); + var functions = plugin.GetFunctionsMetadata().Select(function => function.ToOpenAIFunction()); + var enabledFunctions = new EnabledFunctions(functions, autoInvoke); + var chatCompletionsOptions = new ChatCompletionsOptions(); + var kernel = Kernel.CreateBuilder().Build(); + + kernel.Plugins.Add(plugin); + + // Act + enabledFunctions.ConfigureOptions(kernel, chatCompletionsOptions); + + // Assert + Assert.Equal(ChatCompletionsToolChoice.Auto, chatCompletionsOptions.ToolChoice); + + this.AssertTools(chatCompletionsOptions); + } + + [Fact] + public void RequiredFunctionConfigureOptionsAddsTools() + { + // Arrange + var function = this.GetTestPlugin().GetFunctionsMetadata()[0].ToOpenAIFunction(); + var chatCompletionsOptions = new ChatCompletionsOptions(); + var requiredFunction = new RequiredFunction(function, autoInvoke: true); + + // Act + requiredFunction.ConfigureOptions(null, chatCompletionsOptions); + + // Assert + Assert.NotNull(chatCompletionsOptions.ToolChoice); + + this.AssertTools(chatCompletionsOptions); + } + + private KernelPlugin GetTestPlugin() + { + var function = KernelFunctionFactory.CreateFromMethod( + (string parameter1, string parameter2) => "Result1", + "MyFunction", + "Test Function", + [new KernelParameterMetadata("parameter1"), new KernelParameterMetadata("parameter2")], + new KernelReturnParameterMetadata { ParameterType = typeof(string), Description = "Function Result" }); + + return KernelPluginFactory.CreateFromFunctions("MyPlugin", [function]); + } + + private void AssertTools(ChatCompletionsOptions chatCompletionsOptions) + { + Assert.Single(chatCompletionsOptions.Tools); + + var tool = chatCompletionsOptions.Tools[0] as ChatCompletionsFunctionToolDefinition; + + Assert.NotNull(tool); + + Assert.Equal("MyPlugin_MyFunction", tool.Name); + Assert.Equal("Test Function", tool.Description); + Assert.Equal("{\"type\":\"object\",\"required\":[],\"properties\":{\"parameter1\":{\"type\":\"string\"},\"parameter2\":{\"type\":\"string\"}}}", tool.Parameters.ToString()); + } +} diff --git a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/HandlebarsPromptTemplateTests.cs b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/HandlebarsPromptTemplateTests.cs index aba322d86e..80538e9aff 100644 --- a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/HandlebarsPromptTemplateTests.cs +++ b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/HandlebarsPromptTemplateTests.cs @@ -21,6 +21,20 @@ public sealed class HandlebarsPromptTemplateTests this._arguments = new() { ["input"] = Guid.NewGuid().ToString("X") }; } + [Theory] + [InlineData(true)] + [InlineData(false)] + public void ItInitializesHandlebarsPromptTemplateInstanceCorrectly(bool includeOptions) + { + // Arrange & Act + var template = includeOptions ? + new HandlebarsPromptTemplate(new()) : + new HandlebarsPromptTemplate(new(), new()); + + // Assert + Assert.NotNull(template); + } + [Fact] public async Task ItRendersVariablesAsync() { @@ -41,20 +55,14 @@ public sealed class HandlebarsPromptTemplateTests public async Task ItUsesDefaultValuesAsync() { // Arrange - var template = "Foo {{bar}} {{baz}}"; + var template = "Foo {{bar}} {{baz}}{{null}}{{empty}}"; var promptConfig = InitializeHbPromptConfig(template); - promptConfig.InputVariables.Add(new InputVariable() - { - Name = "bar", - Description = "Bar", - Default = "Bar" - }); - promptConfig.InputVariables.Add(new InputVariable() - { - Name = "baz", - Description = "Baz", - Default = "Baz" - }); + + promptConfig.InputVariables.Add(new() { Name = "bar", Description = "Bar", Default = "Bar" }); + promptConfig.InputVariables.Add(new() { Name = "baz", Description = "Baz", Default = "Baz" }); + promptConfig.InputVariables.Add(new() { Name = "null", Description = "Null", Default = null }); + promptConfig.InputVariables.Add(new() { Name = "empty", Description = "empty", Default = string.Empty }); + var target = (HandlebarsPromptTemplate)this._factory.Create(promptConfig); // Act diff --git a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelFunctionHelpersTests.cs b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelFunctionHelpersTests.cs index cd026d0186..04e58b1d91 100644 --- a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelFunctionHelpersTests.cs +++ b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelFunctionHelpersTests.cs @@ -6,6 +6,7 @@ using System.Globalization; using System.Threading.Tasks; using HandlebarsDotNet; using Microsoft.SemanticKernel; +using Microsoft.SemanticKernel.ChatCompletion; using Microsoft.SemanticKernel.PromptTemplates.Handlebars; using Xunit; using static Extensions.UnitTests.PromptTemplates.Handlebars.TestUtilities; @@ -54,6 +55,30 @@ public sealed class KernelFunctionHelpersTests Assert.Equal("BazBar", result); } + [Fact] + public async Task ItThrowsExceptionWhenPositionalArgumentHasInvalidTypeAsync() + { + // Arrange + var template = "{{Foo-StringifyInt \"twelve\"}}"; + + // Act and Assert + var exception = await Assert.ThrowsAsync(() => this.RenderPromptTemplateAsync(template)); + + Assert.Contains("Invalid parameter type for function", exception.Message, StringComparison.OrdinalIgnoreCase); + } + + [Fact] + public async Task ItThrowsExceptionWhenPositionalArgumentNumberIsIncorrectAsync() + { + // Arrange + var template = "{{Foo-Combine \"Bar\"}}"; + + // Act and Assert + var exception = await Assert.ThrowsAsync(() => this.RenderPromptTemplateAsync(template)); + + Assert.Contains("Invalid parameter count for function", exception.Message, StringComparison.OrdinalIgnoreCase); + } + [Fact] public async Task ItRendersFunctionHelpersWitHashArgumentsAsync() { @@ -76,6 +101,17 @@ public sealed class KernelFunctionHelpersTests Assert.Matches("Parameter .* is required for function", exception.Message); } + [Fact] + public async Task ShouldThrowExceptionWhenArgumentsAreNotProvidedAsync() + { + // Arrange + var template = "{{Foo-Combine}}"; + + // Act and Assert + var exception = await Assert.ThrowsAsync(() => this.RenderPromptTemplateAsync(template)); + Assert.Matches("No arguments are provided for .*", exception.Message); + } + [Fact] public async Task ShouldThrowExceptionWhenFunctionHelperHasInvalidParameterTypeAsync() { @@ -98,6 +134,44 @@ public sealed class KernelFunctionHelpersTests Assert.Contains("Template references a helper that cannot be resolved", exception.Message, StringComparison.CurrentCultureIgnoreCase); } + [Fact] + public async Task ItCanReturnChatMessageContentAsync() + { + // Arrange + var template = "{{Foo-ChatMessageContent \"user\" \"User content\"}}"; + + // Act + var result = await this.RenderPromptTemplateAsync(template); + + // Assert + Assert.Equal("User content", result); + } + + [Theory] + [InlineData("{{Foo-RestApiOperationResponse \"text\" \"text/plain\"}}", "text")] + [InlineData("{{Foo-RestApiOperationResponse \'{\"key\":\"value\"}\' \'application/json\'}}", "[key, value]")] + public async Task ItCanReturnRestApiOperationResponseAsync(string template, string expectedResult) + { + // Arrange and Act + var result = await this.RenderPromptTemplateAsync(template); + + // Assert + Assert.Equal(expectedResult, result); + } + + [Fact] + public async Task ItCanReturnCustomReturnTypeAsync() + { + // Arrange + var template = "{{Foo-CustomReturnType \"text\"}}"; + + // Act + var result = await this.RenderPromptTemplateAsync(template); + + // Assert + Assert.Equal("text", result); + } + private readonly HandlebarsPromptTemplateFactory _factory; private readonly Kernel _kernel; private readonly KernelArguments _arguments; @@ -132,5 +206,26 @@ public sealed class KernelFunctionHelpersTests [KernelFunction, Description("Return number as string")] public string StringifyInt([Description("Number to stringify")] int x) => x.ToString(CultureInfo.InvariantCulture); + + [KernelFunction, Description("Return ChatMessageContent")] + public ChatMessageContent ChatMessageContent(string role, string content) => new(new AuthorRole(role), content); + + [KernelFunction, Description("Return RestApiOperationResponse")] + public RestApiOperationResponse RestApiOperationResponse(string content, string contentType) => new(content, contentType); + + [KernelFunction, Description("Return CustomReturnType")] + public CustomReturnType CustomReturnType(string textProperty) => new(textProperty); + } + + private sealed class CustomReturnType + { + public CustomReturnType(string textProperty) + { + this.TextProperty = textProperty; + } + + public string TextProperty { get; set; } + + public override string ToString() => this.TextProperty; } } diff --git a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelHelperUtilsTests.cs b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelHelperUtilsTests.cs index a401785d57..e009cd61d4 100644 --- a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelHelperUtilsTests.cs +++ b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelHelperUtilsTests.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Globalization; using HandlebarsDotNet; using Microsoft.SemanticKernel.PromptTemplates.Handlebars.Helpers; using Xunit; @@ -37,4 +38,41 @@ public class KernelHelperUtilsTests // Act & Assert Assert.Throws(() => KernelHelpersUtils.RegisterHelperSafe(handlebarsInstance, helperName, (HandlebarsReturnHelper)helper2)); } + + [Theory] + [InlineData(null, false)] + [InlineData(typeof(string), false)] + [InlineData(typeof(nuint), true)] + [InlineData(typeof(nint), true)] + [InlineData(typeof(sbyte), true)] + [InlineData(typeof(short), true)] + [InlineData(typeof(int), true)] + [InlineData(typeof(long), true)] + [InlineData(typeof(byte), true)] + [InlineData(typeof(ushort), true)] + [InlineData(typeof(uint), true)] + [InlineData(typeof(ulong), true)] + [InlineData(typeof(double), true)] + [InlineData(typeof(float), true)] + [InlineData(typeof(decimal), true)] + public void IsNumericTypeWorksCorrectly(Type? type, bool expectedResult) + { + Assert.Equal(expectedResult, KernelHelpersUtils.IsNumericType(type)); + } + + [Theory] + [MemberData(nameof(NumberInputs))] + public void TryParseAnyNumberWorksCorrectly(string number, bool expectedResult) + { + Assert.Equal(expectedResult, KernelHelpersUtils.TryParseAnyNumber(number)); + } + + public static TheoryData NumberInputs => new() + { + { 1234567890123456789L.ToString(CultureInfo.InvariantCulture), true }, + { 9876543210987654321UL.ToString(CultureInfo.InvariantCulture), true }, + { 123.456.ToString(CultureInfo.InvariantCulture), true }, + { 123456789.0123456789m.ToString(CultureInfo.InvariantCulture), true }, + { "test", false }, + }; } diff --git a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelSystemHelpersTests.cs b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelSystemHelpersTests.cs index 67af8abcae..c413e050cb 100644 --- a/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelSystemHelpersTests.cs +++ b/dotnet/src/Extensions/Extensions.UnitTests/PromptTemplates/Handlebars/Helpers/KernelSystemHelpersTests.cs @@ -1,7 +1,9 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Text.Json.Nodes; using System.Threading.Tasks; +using HandlebarsDotNet; using Microsoft.SemanticKernel; using Microsoft.SemanticKernel.PromptTemplates.Handlebars; using Xunit; @@ -31,11 +33,12 @@ public sealed class KernelSystemHelpersTests Assert.Equal("Hello World!", result); } - [Fact] - public async Task ItRendersTemplateWithSetHelperAsync() + [Theory] + [InlineData("{{set name=\"x\" value=10}}{{json x}}")] + [InlineData("{{set \"x\" 10}}{{json x}}")] + public async Task ItRendersTemplateWithSetHelperAsync(string template) { // Arrange - var template = "{{set name=\"x\" value=10}}{{json x}}"; var arguments = new KernelArguments(); // Act @@ -45,14 +48,15 @@ public sealed class KernelSystemHelpersTests Assert.Equal("10", result); } - [Fact] - public async Task ItRendersTemplateWithJsonHelperAsync() + [Theory] + [MemberData(nameof(JsonObjectsToParse))] + public async Task ItRendersTemplateWithJsonHelperAsync(object json) { // Arrange var template = "{{json person}}"; var arguments = new KernelArguments { - { "person", new { name = "Alice", age = 25 } } + { "person", json } }; // Act @@ -62,6 +66,19 @@ public sealed class KernelSystemHelpersTests Assert.Equal("{\"name\":\"Alice\",\"age\":25}", result); } + [Fact] + public async Task ItThrowsExceptionWithJsonHelperWithoutArgumentsAsync() + { + // Arrange + var template = "{{json}}"; + + // Act + var exception = await Assert.ThrowsAsync(() => this.RenderPromptTemplateAsync(template)); + + // Assert + Assert.Equal("`json` helper requires a value to be passed in.", exception.Message); + } + [Fact] public async Task ComplexVariableTypeReturnsObjectAsync() { @@ -200,20 +217,65 @@ public sealed class KernelSystemHelpersTests Assert.Equal("Hello Alice!", result); } - [Fact] - public async Task ItRendersTemplateWithEqualHelperAsync() + [Theory] + [InlineData("{{or true true}}", "True")] + [InlineData("{{or true false}}", "True")] + [InlineData("{{or false false}}", "False")] + [InlineData("{{or x x}}", "True")] + [InlineData("{{or x y}}", "True")] + [InlineData("{{or x z}}", "True")] + [InlineData("{{or y y}}", "False")] + [InlineData("{{or y z}}", "False")] + [InlineData("{{or z z}}", "False")] + public async Task ItRendersTemplateWithOrHelperAsync(string template, string expectedResult) { // Arrange - var template = "{{#if (equals x y)}}Equal{{else}}Not equal{{/if}}"; - var arguments = new KernelArguments { { "x", 10 }, { "y", 10 } }; + var arguments = new KernelArguments { { "x", true }, { "y", false }, { "z", null } }; // Act var result = await this.RenderPromptTemplateAsync(template, arguments); // Assert - Assert.Equal("Equal", result); + Assert.Equal(expectedResult, result); } + [Theory] + [InlineData("{{#if (equals x y)}}Equal{{else}}Not equal{{/if}}", "Equal")] + [InlineData("{{#if (equals x)}}Equal{{else}}Not equal{{/if}}", "Not equal")] + [InlineData("{{#if (equals a b)}}Equal{{else}}Not equal{{/if}}", "Not equal")] + [InlineData("{{#if (equals b z)}}Equal{{else}}Not equal{{/if}}", "Equal")] + public async Task ItRendersTemplateWithEqualHelperAsync(string template, string expectedResult) + { + // Arrange + var arguments = new KernelArguments { { "x", 10 }, { "y", 10 }, { "a", null }, { "b", "test" }, { "z", "test" } }; + + // Act + var result = await this.RenderPromptTemplateAsync(template, arguments); + + // Assert + Assert.Equal(expectedResult, result); + } + + [Fact] + public async Task ItThrowsExceptionIfMessageDoesNotContainRoleAsync() + { + // Arrange + var template = "{{#message attribute=\"value\"}}Hello World!{{/message}}"; + + // Act & Assert + var exception = await Assert.ThrowsAsync(() => this.RenderPromptTemplateAsync(template)); + + // Assert + Assert.Equal("Message must have a role.", exception.Message); + } + + public static TheoryData JsonObjectsToParse => new() + { + new { name = "Alice", age = 25 }, + "{\"name\":\"Alice\",\"age\":25}", + JsonNode.Parse("{\"name\":\"Alice\",\"age\":25}")! + }; + #region private private readonly HandlebarsPromptTemplateFactory _factory; diff --git a/dotnet/src/Extensions/PromptTemplates.Handlebars/Helpers/KernelHelpers/KernelSystemHelpers.cs b/dotnet/src/Extensions/PromptTemplates.Handlebars/Helpers/KernelHelpers/KernelSystemHelpers.cs index a0ddd1dbcb..6b562d17fb 100644 --- a/dotnet/src/Extensions/PromptTemplates.Handlebars/Helpers/KernelHelpers/KernelSystemHelpers.cs +++ b/dotnet/src/Extensions/PromptTemplates.Handlebars/Helpers/KernelHelpers/KernelSystemHelpers.cs @@ -3,7 +3,6 @@ using System.Collections.Generic; using System.Linq; using System.Text.Json; -using System.Text.Json.Nodes; using HandlebarsDotNet; using HandlebarsDotNet.Compiler; using static Microsoft.SemanticKernel.PromptTemplates.Handlebars.Helpers.KernelHelpersUtils; @@ -84,18 +83,19 @@ internal static class KernelSystemHelpers handlebarsInstance.RegisterHelper("json", (in HelperOptions options, in Context context, in Arguments arguments) => { - if (arguments.Length == 0 || arguments[0] is null) + if (arguments.Length == 0) { throw new HandlebarsRuntimeException("`json` helper requires a value to be passed in."); } var args = ProcessArguments(arguments, variables); object objectToSerialize = args[0]; - var type = objectToSerialize.GetType(); - return type == typeof(string) ? objectToSerialize - : type == typeof(JsonNode) ? objectToSerialize.ToString() - : JsonSerializer.Serialize(objectToSerialize); + return objectToSerialize switch + { + string stringObject => objectToSerialize, + _ => JsonSerializer.Serialize(objectToSerialize) + }; }); handlebarsInstance.RegisterHelper("concat", (in HelperOptions options, in Context context, in Arguments arguments) => @@ -130,7 +130,15 @@ internal static class KernelSystemHelpers handlebarsInstance.RegisterHelper("or", (in HelperOptions options, in Context context, in Arguments arguments) => { var args = ProcessArguments(arguments, variables); - return args.Any(arg => arg != null && arg is not false); + + return args.Any(arg => + { + return arg switch + { + bool booleanArg => booleanArg, + _ => arg is null + }; + }); }); handlebarsInstance.RegisterHelper("add", (in HelperOptions options, in Context context, in Arguments arguments) => diff --git a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationResponseTests.cs b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationResponseTests.cs index 7724926754..9e96fa5991 100644 --- a/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationResponseTests.cs +++ b/dotnet/src/Functions/Functions.UnitTests/OpenApi/RestApiOperationResponseTests.cs @@ -101,4 +101,19 @@ public class RestApiOperationResponseTests //Assert Assert.False(result); } + + [Theory] + [InlineData(null, "")] + [InlineData("content", "content")] + public void ToStringReturnsString(object? content, string expectedContent) + { + // Arrange + var response = new RestApiOperationResponse(content!, "application/json"); + + // Act + var result = response.ToString(); + + // Assert + Assert.Equal(expectedContent, result); + } } diff --git a/dotnet/src/InternalUtilities/src/Diagnostics/CompilerServicesAttributes.cs b/dotnet/src/InternalUtilities/src/Diagnostics/CompilerServicesAttributes.cs index ee24ada7de..9ce82b36c0 100644 --- a/dotnet/src/InternalUtilities/src/Diagnostics/CompilerServicesAttributes.cs +++ b/dotnet/src/InternalUtilities/src/Diagnostics/CompilerServicesAttributes.cs @@ -4,11 +4,14 @@ // The .NET Foundation licenses this file to you under the MIT license. // See the LICENSE file in the project root for more information. +using System.Diagnostics.CodeAnalysis; + namespace System.Runtime.CompilerServices; #if !NETCOREAPP [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = false)] +[ExcludeFromCodeCoverage] internal sealed class CallerArgumentExpressionAttribute : Attribute { public CallerArgumentExpressionAttribute(string parameterName) diff --git a/dotnet/src/InternalUtilities/src/Diagnostics/ExceptionExtensions.cs b/dotnet/src/InternalUtilities/src/Diagnostics/ExceptionExtensions.cs index 10a9dad6c3..d23173bdec 100644 --- a/dotnet/src/InternalUtilities/src/Diagnostics/ExceptionExtensions.cs +++ b/dotnet/src/InternalUtilities/src/Diagnostics/ExceptionExtensions.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Diagnostics.CodeAnalysis; using System.Threading; namespace System; @@ -7,6 +8,7 @@ namespace System; /// /// Exception extension methods. /// +[ExcludeFromCodeCoverage] internal static class ExceptionExtensions { /// diff --git a/dotnet/src/InternalUtilities/src/Diagnostics/ExperimentalAttribute.cs b/dotnet/src/InternalUtilities/src/Diagnostics/ExperimentalAttribute.cs index 11b2df8c5e..1332155b0d 100644 --- a/dotnet/src/InternalUtilities/src/Diagnostics/ExperimentalAttribute.cs +++ b/dotnet/src/InternalUtilities/src/Diagnostics/ExperimentalAttribute.cs @@ -14,6 +14,7 @@ namespace System.Diagnostics.CodeAnalysis; /// This attribute allows call sites to be flagged with a diagnostic that indicates that an experimental /// feature is used. Authors can use this attribute to ship preview features in their assemblies. /// +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | diff --git a/dotnet/src/InternalUtilities/src/Diagnostics/NullableAttributes.cs b/dotnet/src/InternalUtilities/src/Diagnostics/NullableAttributes.cs index ce3d5e8be4..34f0de31ec 100644 --- a/dotnet/src/InternalUtilities/src/Diagnostics/NullableAttributes.cs +++ b/dotnet/src/InternalUtilities/src/Diagnostics/NullableAttributes.cs @@ -36,6 +36,7 @@ internal sealed class NotNullAttribute : Attribute } /// Specifies that when a method returns , the parameter may be null even if the corresponding type disallows it. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] internal sealed class MaybeNullWhenAttribute : Attribute { @@ -50,6 +51,7 @@ internal sealed class MaybeNullWhenAttribute : Attribute } /// Specifies that when a method returns , the parameter will not be null even if the corresponding type allows it. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] internal sealed class NotNullWhenAttribute : Attribute { @@ -64,6 +66,7 @@ internal sealed class NotNullWhenAttribute : Attribute } /// Specifies that the output will be non-null if the named parameter is non-null. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.ReturnValue, AllowMultiple = true, Inherited = false)] internal sealed class NotNullIfNotNullAttribute : Attribute { @@ -84,6 +87,7 @@ internal sealed class DoesNotReturnAttribute : Attribute } /// Specifies that the method will not return if the associated Boolean parameter is passed the specified value. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Parameter, Inherited = false)] internal sealed class DoesNotReturnIfAttribute : Attribute { @@ -103,6 +107,7 @@ internal sealed class DoesNotReturnIfAttribute : Attribute #if !NETCOREAPP || NETCOREAPP3_1 /// Specifies that the method or property will ensure that the listed field and property members have not-null values. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] internal sealed class MemberNotNullAttribute : Attribute { @@ -124,6 +129,7 @@ internal sealed class MemberNotNullAttribute : Attribute } /// Specifies that the method or property will ensure that the listed field and property members have not-null values when returning with the specified return value condition. +[ExcludeFromCodeCoverage] [AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)] internal sealed class MemberNotNullWhenAttribute : Attribute { diff --git a/dotnet/src/InternalUtilities/src/Diagnostics/Verify.cs b/dotnet/src/InternalUtilities/src/Diagnostics/Verify.cs index 3f0198ed1f..c8e754c40c 100644 --- a/dotnet/src/InternalUtilities/src/Diagnostics/Verify.cs +++ b/dotnet/src/InternalUtilities/src/Diagnostics/Verify.cs @@ -10,6 +10,7 @@ using System.Text.RegularExpressions; namespace Microsoft.SemanticKernel; +[ExcludeFromCodeCoverage] internal static class Verify { private static readonly Regex s_asciiLettersDigitsUnderscoresRegex = new("^[0-9A-Za-z_]*$"); diff --git a/dotnet/src/InternalUtilities/src/Http/HttpClientExtensions.cs b/dotnet/src/InternalUtilities/src/Http/HttpClientExtensions.cs index 8c75851dc1..638a0026bb 100644 --- a/dotnet/src/InternalUtilities/src/Http/HttpClientExtensions.cs +++ b/dotnet/src/InternalUtilities/src/Http/HttpClientExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using System.Net; using System.Net.Http; using System.Threading; @@ -8,6 +9,7 @@ using System.Threading.Tasks; namespace Microsoft.SemanticKernel.Http; +[ExcludeFromCodeCoverage] internal static class HttpClientExtensions { /// diff --git a/dotnet/src/InternalUtilities/src/Http/HttpClientProvider.cs b/dotnet/src/InternalUtilities/src/Http/HttpClientProvider.cs index 198f383cd0..d11b6dfa86 100644 --- a/dotnet/src/InternalUtilities/src/Http/HttpClientProvider.cs +++ b/dotnet/src/InternalUtilities/src/Http/HttpClientProvider.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using System.Net.Http; using Microsoft.Extensions.DependencyInjection; @@ -11,6 +12,7 @@ namespace Microsoft.SemanticKernel.Http; /// /// Provides functionality for retrieving instances of HttpClient. /// +[ExcludeFromCodeCoverage] internal static class HttpClientProvider { /// diff --git a/dotnet/src/InternalUtilities/src/Http/HttpContentExtensions.cs b/dotnet/src/InternalUtilities/src/Http/HttpContentExtensions.cs index 95e851f8c4..917e8d3af6 100644 --- a/dotnet/src/InternalUtilities/src/Http/HttpContentExtensions.cs +++ b/dotnet/src/InternalUtilities/src/Http/HttpContentExtensions.cs @@ -1,5 +1,6 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Diagnostics.CodeAnalysis; using System.IO; using System.Net.Http; using System.Threading.Tasks; @@ -9,6 +10,7 @@ namespace Microsoft.SemanticKernel.Http; /// /// Provides extension methods for working with HTTP content in a way that translates HttpRequestExceptions into HttpOperationExceptions. /// +[ExcludeFromCodeCoverage] internal static class HttpContentExtensions { /// diff --git a/dotnet/src/InternalUtilities/src/Http/HttpHeaderValues.cs b/dotnet/src/InternalUtilities/src/Http/HttpHeaderValues.cs index df52d8c0b3..9f918c6c0d 100644 --- a/dotnet/src/InternalUtilities/src/Http/HttpHeaderValues.cs +++ b/dotnet/src/InternalUtilities/src/Http/HttpHeaderValues.cs @@ -1,8 +1,11 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Diagnostics.CodeAnalysis; + namespace Microsoft.SemanticKernel.Http; /// Provides HTTP header values for common purposes. +[ExcludeFromCodeCoverage] internal static class HttpHeaderValues { /// User agent string to use for all HTTP requests issued by Semantic Kernel. diff --git a/dotnet/src/InternalUtilities/src/Http/HttpRequest.cs b/dotnet/src/InternalUtilities/src/Http/HttpRequest.cs index 883eb07d9d..d04afb58d5 100644 --- a/dotnet/src/InternalUtilities/src/Http/HttpRequest.cs +++ b/dotnet/src/InternalUtilities/src/Http/HttpRequest.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using System.Net.Http; using System.Net.Http.Headers; using System.Text; @@ -9,6 +10,7 @@ using Microsoft.SemanticKernel.Text; namespace Microsoft.SemanticKernel; +[ExcludeFromCodeCoverage] internal static class HttpRequest { private static readonly HttpMethod s_patchMethod = new("PATCH"); diff --git a/dotnet/src/InternalUtilities/src/Linq/AsyncEnumerable.cs b/dotnet/src/InternalUtilities/src/Linq/AsyncEnumerable.cs index 19c6d44d1d..844ae7e2f5 100644 --- a/dotnet/src/InternalUtilities/src/Linq/AsyncEnumerable.cs +++ b/dotnet/src/InternalUtilities/src/Linq/AsyncEnumerable.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Threading; using System.Threading.Tasks; using Microsoft.SemanticKernel; @@ -8,6 +9,7 @@ using Microsoft.SemanticKernel; // Used for compatibility with System.Linq.Async Nuget pkg namespace System.Linq; +[ExcludeFromCodeCoverage] internal static class AsyncEnumerable { public static IAsyncEnumerable Empty() => EmptyAsyncEnumerable.Instance; diff --git a/dotnet/src/InternalUtilities/src/System/EnvExtensions.cs b/dotnet/src/InternalUtilities/src/System/EnvExtensions.cs index 960a01d64d..05cb235d71 100644 --- a/dotnet/src/InternalUtilities/src/System/EnvExtensions.cs +++ b/dotnet/src/InternalUtilities/src/System/EnvExtensions.cs @@ -1,7 +1,10 @@ // Copyright (c) Microsoft. All rights reserved. +using System.Diagnostics.CodeAnalysis; + namespace System; +[ExcludeFromCodeCoverage] internal static class EnvExtensions { /// diff --git a/dotnet/src/InternalUtilities/src/System/InternalTypeConverter.cs b/dotnet/src/InternalUtilities/src/System/InternalTypeConverter.cs index 4bc817a2f6..bd92f686ab 100644 --- a/dotnet/src/InternalUtilities/src/System/InternalTypeConverter.cs +++ b/dotnet/src/InternalUtilities/src/System/InternalTypeConverter.cs @@ -3,6 +3,7 @@ using System; using System.Collections.Concurrent; using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; using System.Globalization; namespace Microsoft.SemanticKernel; @@ -10,6 +11,7 @@ namespace Microsoft.SemanticKernel; /// /// Provides internal utility methods for converting types to strings with consideration for CultureInfo. /// +[ExcludeFromCodeCoverage] internal static class InternalTypeConverter { /// diff --git a/dotnet/src/InternalUtilities/src/System/TypeConverterFactory.cs b/dotnet/src/InternalUtilities/src/System/TypeConverterFactory.cs index 3189d4cc3c..2049dda894 100644 --- a/dotnet/src/InternalUtilities/src/System/TypeConverterFactory.cs +++ b/dotnet/src/InternalUtilities/src/System/TypeConverterFactory.cs @@ -2,6 +2,7 @@ using System; using System.ComponentModel; +using System.Diagnostics.CodeAnalysis; using System.Reflection; namespace Microsoft.SemanticKernel; @@ -9,6 +10,7 @@ namespace Microsoft.SemanticKernel; /// /// Factory for creating TypeConverter instances based on a provided type. /// +[ExcludeFromCodeCoverage] internal static class TypeConverterFactory { /// diff --git a/dotnet/src/InternalUtilities/src/Text/JsonOptionsCache.cs b/dotnet/src/InternalUtilities/src/Text/JsonOptionsCache.cs index f63ce6c0d9..c8278b4b06 100644 --- a/dotnet/src/InternalUtilities/src/Text/JsonOptionsCache.cs +++ b/dotnet/src/InternalUtilities/src/Text/JsonOptionsCache.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using System.Text.Json; namespace Microsoft.SemanticKernel.Text; @@ -11,6 +12,7 @@ namespace Microsoft.SemanticKernel.Text; /// Once the System.Text.Json package is upgraded to 8.0+, this will no longer be /// necessary and the actual default can be used. /// +[ExcludeFromCodeCoverage] internal static class JsonOptionsCache { /// Singleton for . diff --git a/dotnet/src/InternalUtilities/src/Text/ReadOnlyMemoryConverter.cs b/dotnet/src/InternalUtilities/src/Text/ReadOnlyMemoryConverter.cs index ecce02508e..1a754aa552 100644 --- a/dotnet/src/InternalUtilities/src/Text/ReadOnlyMemoryConverter.cs +++ b/dotnet/src/InternalUtilities/src/Text/ReadOnlyMemoryConverter.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System; +using System.Diagnostics.CodeAnalysis; using System.Runtime.InteropServices; using System.Text.Json; using System.Text.Json.Serialization; @@ -12,6 +13,7 @@ namespace Microsoft.SemanticKernel.Text; // It should be removed once SK projects upgrade to System.Text.Json v8.0.0. /// Provides a converter for . +[ExcludeFromCodeCoverage] internal sealed class ReadOnlyMemoryConverter : JsonConverter> { /// An instance of a converter for float[] that all operations delegate to. diff --git a/dotnet/src/InternalUtilities/src/Type/TypeExtensions.cs b/dotnet/src/InternalUtilities/src/Type/TypeExtensions.cs index 8ca4be34dc..266ac9ac0b 100644 --- a/dotnet/src/InternalUtilities/src/Type/TypeExtensions.cs +++ b/dotnet/src/InternalUtilities/src/Type/TypeExtensions.cs @@ -1,6 +1,7 @@ // Copyright (c) Microsoft. All rights reserved. using System.Collections.Generic; +using System.Diagnostics.CodeAnalysis; using System.Threading.Tasks; namespace System; @@ -8,6 +9,7 @@ namespace System; /// /// Extensions methods for . /// +[ExcludeFromCodeCoverage] internal static class TypeExtensions { /// diff --git a/dotnet/src/Plugins/Plugins.UnitTests/Plugins.UnitTests.csproj b/dotnet/src/Plugins/Plugins.UnitTests/Plugins.UnitTests.csproj index 705bd9dce4..60d06162de 100644 --- a/dotnet/src/Plugins/Plugins.UnitTests/Plugins.UnitTests.csproj +++ b/dotnet/src/Plugins/Plugins.UnitTests/Plugins.UnitTests.csproj @@ -22,6 +22,10 @@ runtime; build; native; contentfiles; analyzers; buildtransitive all + + runtime; build; native; contentfiles; analyzers; buildtransitive + all + diff --git a/dotnet/src/SemanticKernel.UnitTests/Contents/ImageContentTests.cs b/dotnet/src/SemanticKernel.UnitTests/Contents/ImageContentTests.cs new file mode 100644 index 0000000000..cac559777f --- /dev/null +++ b/dotnet/src/SemanticKernel.UnitTests/Contents/ImageContentTests.cs @@ -0,0 +1,29 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using Microsoft.SemanticKernel; +using Xunit; + +namespace SemanticKernel.UnitTests.Contents; + +/// +/// Unit tests for class. +/// +public sealed class ImageContentTests +{ + [Fact] + public void ToStringReturnsString() + { + // Arrange + var content1 = new ImageContent(null!); + var content2 = new ImageContent(new Uri("https://endpoint/")); + + // Act + var result1 = content1.ToString(); + var result2 = content2.ToString(); + + // Assert + Assert.Empty(result1); + Assert.Equal("https://endpoint/", result2); + } +} diff --git a/dotnet/src/SemanticKernel.UnitTests/Utilities/TypeExtensionsTests.cs b/dotnet/src/SemanticKernel.UnitTests/Utilities/TypeExtensionsTests.cs new file mode 100644 index 0000000000..7533af205d --- /dev/null +++ b/dotnet/src/SemanticKernel.UnitTests/Utilities/TypeExtensionsTests.cs @@ -0,0 +1,37 @@ +// Copyright (c) Microsoft. All rights reserved. + +using System; +using System.Collections.Generic; +using System.Threading.Tasks; +using Xunit; +using TypeExtensions = System.TypeExtensions; + +namespace SemanticKernel.UnitTests.Utilities; + +/// +/// Unit tests for class. +/// +public sealed class TypeExtensionsTests +{ + [Theory] + [InlineData(null, typeof(object), false)] + [InlineData(typeof(TestType), typeof(object), false)] + [InlineData(typeof(Task), typeof(TestType), true)] + [InlineData(typeof(TestType?), typeof(TestType), true)] + [InlineData(typeof(ValueTask), typeof(TestType), true)] + [InlineData(typeof(IEnumerable), typeof(List), true)] + [InlineData(typeof(IList), typeof(List), true)] + [InlineData(typeof(ICollection), typeof(List), true)] + [InlineData(typeof(IDictionary), typeof(Dictionary), true)] + public void TryGetGenericResultTypeWorksCorrectly(Type? type, Type expectedType, bool expectedResult) + { + // Arrange & Act + var result = type.TryGetGenericResultType(out var resultType); + + // Assert + Assert.Equal(expectedResult, result); + Assert.Equal(expectedType, resultType); + } + + private struct TestType { } +}