Add more test cases for OpenApiHttpTriggerContext (Azure#463)

justinyoo · Derich367 · commit dba434e06bcb · 2022-08-31T09:07:31.000+02:00
diff --git a/src/Microsoft.Azure.Functions.Worker.Extensions.OpenApi/OpenApiHttpTriggerContext.cs b/src/Microsoft.Azure.Functions.Worker.Extensions.OpenApi/OpenApiHttpTriggerContext.cs
@@ -281,6 +281,7 @@ private async Task<string> GetRuntimeFilenameAsync(string functionAppDirectory)
 
             var runtimes = dependencyManifests
                 .Select(manifest => manifest.Targets[manifest.RuntimeTarget.Name].First())
+                .Where(manifest => manifest.Value.Dependencies != null)
                 .Select(target => new
                 {
                     Name = target.Key.Split('/').First(),
diff --git a/src/Microsoft.Azure.WebJobs.Extensions.OpenApi.Core/Filters/DocumentFilterCollection.cs b/src/Microsoft.Azure.WebJobs.Extensions.OpenApi.Core/Filters/DocumentFilterCollection.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 
 using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Abstractions;
-using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Extensions;
 
 namespace Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Filters
 {
@@ -10,21 +9,13 @@ namespace Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Filters
     /// </summary>
     public class DocumentFilterCollection
     {
-        /// <summary>
-        /// Initializes a new instance of the <see cref="DocumentFilterCollection"/> class.
-        /// </summary>
-        public DocumentFilterCollection()
-        {
-            this.DocumentFilters = new List<IDocumentFilter>();
-        }
-
         /// <summary>
         /// Initializes a new instance of the <see cref="DocumentFilterCollection"/> class.
         /// </summary>
         /// <param name="documentFilters">List of <see cref="IDocumentFilter"/> instances.</param>
-        public DocumentFilterCollection(List<IDocumentFilter> documentFilters)
+        public DocumentFilterCollection(List<IDocumentFilter> documentFilters = null)
         {
-            this.DocumentFilters = documentFilters.ThrowIfNullOrDefault();
+            this.DocumentFilters = documentFilters ?? new List<IDocumentFilter>();
         }
 
         /// <summary>
diff --git a/test/Microsoft.Azure.Functions.Worker.Extensions.OpenApi.Tests/OpenApiHttpTriggerContextTests.cs b/test/Microsoft.Azure.Functions.Worker.Extensions.OpenApi.Tests/OpenApiHttpTriggerContextTests.cs
@@ -9,17 +9,29 @@
 using Microsoft.Azure.Functions.Worker.Extensions.OpenApi.Functions;
 using Microsoft.Azure.Functions.Worker.Extensions.OpenApi.Tests.Fakes;
 using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Abstractions;
+using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Enums;
 using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Extensions;
 using Microsoft.OpenApi;
 using Microsoft.VisualStudio.TestTools.UnitTesting;
 
 using Moq;
 
+using Newtonsoft.Json.Serialization;
+
 namespace Microsoft.Azure.Functions.Worker.Extensions.OpenApi.Tests
 {
     [TestClass]
     public class OpenApiHttpTriggerContextTests
     {
+        [TestCleanup]
+        public void CleanUp()
+        {
+            Environment.SetEnvironmentVariable("AZURE_FUNCTIONS_ENVIRONMENT", null);
+            Environment.SetEnvironmentVariable("OpenApi__AuthLevel__Document", null);
+            Environment.SetEnvironmentVariable("OpenApi__AuthLevel__UI", null);
+            Environment.SetEnvironmentVariable("OpenApi__ApiKey", null);
+        }
+
         [DataTestMethod]
         [DataRow(typeof(OpenApiHttpTriggerContextTests))]
         public async Task Given_Type_When_Initiated_Then_It_Should_Return_ApplicationAssemblyWithGivenType(Type type)
@@ -112,8 +124,60 @@ public async Task Given_Type_When_Initiated_Then_It_Should_Return_HttpSettings()
             var settings = (await context.SetApplicationAssemblyAsync(location, false))
                                          .HttpSettings;
 
+            settings.Should().NotBeNull();
             settings.RoutePrefix.Should().Be("api");
+        }
+
+        [TestMethod]
+        public async Task Given_Type_When_Initiated_Then_It_Should_Return_Document()
+        {
+            var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
+            var context = new OpenApiHttpTriggerContext();
+
+            var document = (await context.SetApplicationAssemblyAsync(location, false))
+                                         .Document;
+
+            document.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public async Task Given_Type_When_Initiated_Then_It_Should_Return_SwaggerUI()
+        {
+            var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
+            var context = new OpenApiHttpTriggerContext();
+
+            var swaggerUI = (await context.SetApplicationAssemblyAsync(location, false))
+                                         .SwaggerUI;
+
+            swaggerUI.Should().NotBeNull();
+        }
+
+        [TestMethod]
+        public async Task Given_Type_When_Initiated_Then_It_Should_Return_NamingStrategy()
+        {
+            var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
+            var context = new OpenApiHttpTriggerContext();
+
+            var namingStrategy = (await context.SetApplicationAssemblyAsync(location, false))
+                                         .NamingStrategy;
+
+            namingStrategy.Should().NotBeNull();
+            namingStrategy.Should().BeOfType<CamelCaseNamingStrategy>();
+        }
+
+        [DataTestMethod]
+        [DataRow("Development", true)]
+        [DataRow("Production", false)]
+        public async Task Given_Type_When_Initiated_Then_It_Should_Return_IsDevelopment(string environment, bool expected)
+        {
+            Environment.SetEnvironmentVariable("AZURE_FUNCTIONS_ENVIRONMENT", environment);
+            var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
+            var context = new OpenApiHttpTriggerContext();
 
+            var isDevelopment = (await context.SetApplicationAssemblyAsync(location, false))
+                                         .IsDevelopment;
+
+            isDevelopment.Should().Be(expected);
         }
 
         [TestMethod]
@@ -131,32 +195,193 @@ public async Task Given_Authorization_When_AuthorizeAsync_Invoked_Then_It_Should
             result.Payload.Should().Be(FakeOpenApiHttpTriggerAuthorization.Payload);
         }
 
+        [TestMethod]
+        public void Given_Type_When_GetVisitorCollection_Invoked_Then_It_Should_Return_Result()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetVisitorCollection();
+
+            result.Should().NotBeNull();
+            result.Visitors.Should().NotBeNull();
+            result.Visitors.Should().HaveCountGreaterThan(0);
+        }
+
+        [TestMethod]
+        public void Given_NoVersion_When_GetOpenApiVersionType_Invoked_Then_It_Should_Return_V2()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetOpenApiVersionType();
+
+            result.Should().Be(OpenApiVersionType.V2);
+        }
+
+        [TestMethod]
+        public void Given_InvalidVersion_When_GetOpenApiVersionType_Invoked_Then_It_Should_Throw_Exception()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            Action action = () => context.GetOpenApiVersionType("v1");
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+
+        [DataTestMethod]
+        [DataRow("v2", OpenApiVersionType.V2)]
+        [DataRow("V2", OpenApiVersionType.V2)]
+        [DataRow("v3", OpenApiVersionType.V3)]
+        [DataRow("V3", OpenApiVersionType.V3)]
+        public void Given_ValidVersion_When_GetOpenApiVersionType_Invoked_Then_It_Should_Return_V2(string version, OpenApiVersionType expected)
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetOpenApiVersionType(version);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public void Given_InvalidVersion_When_GetOpenApiSpecVersion_Invoked_Then_It_Should_Throw_Exception()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            Action action = () => context.GetOpenApiSpecVersion("v1");
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+
         [DataTestMethod]
         [DataRow("v2", OpenApiSpecVersion.OpenApi2_0)]
+        [DataRow("V2", OpenApiSpecVersion.OpenApi2_0)]
         [DataRow("v3", OpenApiSpecVersion.OpenApi3_0)]
-        public async Task Given_Type_When_GetOpenApiSpecVersion_Invoked_Then_It_Should_Return_Result(string version, OpenApiSpecVersion expected)
+        [DataRow("V3", OpenApiSpecVersion.OpenApi3_0)]
+        public void Given_Type_When_GetOpenApiSpecVersion_Invoked_Then_It_Should_Return_Result(string version, OpenApiSpecVersion expected)
         {
-            var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
             var context = new OpenApiHttpTriggerContext();
 
-            var result = (await context.SetApplicationAssemblyAsync(location, false))
-                                       .GetOpenApiSpecVersion(version);
+            var result = context.GetOpenApiSpecVersion(version);
 
             result.Should().Be(expected);
         }
 
+        [TestMethod]
+        public void Given_InvalidVersion_When_GetOpenApiFormat_Invoked_Then_It_Should_Throw_Exception()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            Action action = () => context.GetOpenApiFormat("text");
+
+            action.Should().Throw<InvalidOperationException>();
+        }
+
         [DataTestMethod]
+        [DataRow("yml", OpenApiFormat.Yaml)]
+        [DataRow("YML", OpenApiFormat.Yaml)]
         [DataRow("yaml", OpenApiFormat.Yaml)]
+        [DataRow("YAML", OpenApiFormat.Yaml)]
         [DataRow("json", OpenApiFormat.Json)]
-        public async Task Given_Type_When_GetOpenApiSpecVersion_Invoked_Then_It_Should_Return_Result(string format, OpenApiFormat expected)
+        [DataRow("JSON", OpenApiFormat.Json)]
+        public void Given_Type_When_GetOpenApiSpecVersion_Invoked_Then_It_Should_Return_Result(string format, OpenApiFormat expected)
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetOpenApiFormat(format);
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public void Given_NoAuthLevel_When_GetDocumentAuthLevel_Invoked_Then_It_Should_Return_Anonymous()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetDocumentAuthLevel();
+
+            result.Should().Be(OpenApiAuthLevelType.Anonymous);
+        }
+
+        [DataTestMethod]
+        [DataRow("Anonymous", OpenApiAuthLevelType.Anonymous)]
+        [DataRow("User", OpenApiAuthLevelType.User)]
+        [DataRow("Function", OpenApiAuthLevelType.Function)]
+        [DataRow("System", OpenApiAuthLevelType.System)]
+        [DataRow("Admin", OpenApiAuthLevelType.Admin)]
+        [DataRow("ServiceAccount", OpenApiAuthLevelType.Anonymous)]
+        public void Given_AuthLevel_When_GetDocumentAuthLevel_Invoked_Then_It_Should_Return_Result(string authLevel, OpenApiAuthLevelType expected)
+        {
+            Environment.SetEnvironmentVariable("OpenApi__AuthLevel__Document", authLevel);
+
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetDocumentAuthLevel();
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public void Given_NoAuthLevel_When_GetUIAuthLevel_Invoked_Then_It_Should_Return_Anonymous()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetUIAuthLevel();
+
+            result.Should().Be(OpenApiAuthLevelType.Anonymous);
+        }
+
+        [DataTestMethod]
+        [DataRow("Anonymous", OpenApiAuthLevelType.Anonymous)]
+        [DataRow("User", OpenApiAuthLevelType.User)]
+        [DataRow("Function", OpenApiAuthLevelType.Function)]
+        [DataRow("System", OpenApiAuthLevelType.System)]
+        [DataRow("Admin", OpenApiAuthLevelType.Admin)]
+        [DataRow("ServiceAccount", OpenApiAuthLevelType.Anonymous)]
+        public void Given_AuthLevel_When_GetUIAuthLevel_Invoked_Then_It_Should_Return_Result(string authLevel, OpenApiAuthLevelType expected)
+        {
+            Environment.SetEnvironmentVariable("OpenApi__AuthLevel__UI", authLevel);
+
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetUIAuthLevel();
+
+            result.Should().Be(expected);
+        }
+
+        [TestMethod]
+        public void Given_NoApiKey_When_GetSwaggerAuthKey_Invoked_Then_It_Should_Return_Empty()
+        {
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetSwaggerAuthKey();
+
+            result.Should().BeEmpty();
+        }
+
+        [DataTestMethod]
+        [DataRow("hello world")]
+        public void Given_ApiKey_When_GetSwaggerAuthKey_Invoked_Then_It_Should_Return_Result(string apiKey)
+        {
+            Environment.SetEnvironmentVariable("OpenApi__ApiKey", apiKey);
+
+            var context = new OpenApiHttpTriggerContext();
+
+            var result = context.GetSwaggerAuthKey();
+
+            result.Should().Be(apiKey);
+        }
+
+        [TestMethod]
+        public async Task Given_Type_When_GetDocumentFilterCollection_Invoked_Then_It_Should_Return_Result()
         {
             var location = new FileInfo(Assembly.GetExecutingAssembly().Location).Directory.FullName;
             var context = new OpenApiHttpTriggerContext();
 
             var result = (await context.SetApplicationAssemblyAsync(location, false))
-                                       .GetOpenApiFormat(format);
+                                      .GetDocumentFilterCollection();
 
-            result.Should().Be(expected);
+            result.Should().NotBeNull();
+            result.DocumentFilters.Should().NotBeNull();
+            result.DocumentFilters.Should().HaveCount(0);
         }
     }
 }
diff --git a/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Tests/Filters/DocumentFilterCollectionTests.cs b/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Tests/Filters/DocumentFilterCollectionTests.cs
@@ -0,0 +1,37 @@
+using System.Linq;
+
+using FluentAssertions;
+
+using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Abstractions;
+using Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Filters;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+using Moq;
+
+namespace Microsoft.Azure.WebJobs.Extensions.OpenApi.Core.Tests.Filters
+{
+    [TestClass]
+    public class DocumentFilterCollectionTests
+    {
+        [TestMethod]
+        public void Given_Null_When_Instantated_Then_It_Should_Return_Result()
+        {
+            var collection = new DocumentFilterCollection();
+
+            collection.DocumentFilters.Should().NotBeNull();
+            collection.DocumentFilters.Should().HaveCount(0);
+        }
+
+        [DataTestMethod]
+        [DataRow(1)]
+        [DataRow(2)]
+        public void Given_Filters_When_Instantated_Then_It_Should_Return_Result(int count)
+        {
+            var filters = Enumerable.Range(0, count).Select(i => new Mock<IDocumentFilter>().Object).ToList();
+            var collection = new DocumentFilterCollection(filters);
+
+            collection.DocumentFilters.Should().NotBeNull();
+            collection.DocumentFilters.Should().HaveCount(count);
+        }
+    }
+}
diff --git a/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Tests/OpenApiHttpTriggerContextTests.cs b/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Tests/OpenApiHttpTriggerContextTests.cs
diff --git a/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Tests/local.settings.json b/test/Microsoft.Azure.WebJobs.Extensions.OpenApi.Tests/local.settings.json

Original file line number	Diff line number	Diff line change
`@@ -281,6 +281,7 @@ private async Task<string> GetRuntimeFilenameAsync(string functionAppDirectory)`
`281`	`281`
`282`	`282`	`var runtimes = dependencyManifests`
`283`	`283`	`.Select(manifest => manifest.Targets[manifest.RuntimeTarget.Name].First())`
	`284`	`+ .Where(manifest => manifest.Value.Dependencies != null)`
`284`	`285`	`.Select(target => new`
`285`	`286`	`{`
`286`	`287`	`Name = target.Key.Split('/').First(),`