Add some missing unit tests

src/AzureMapsControl.Components/Extensions.cs

@@ -1,6 +1,7 @@
 namespace AzureMapsControl.Components
 {
     using System;
+    using System.Diagnostics.CodeAnalysis;
 
     using AzureMapsControl.Components.Animations;
     using AzureMapsControl.Components.Configuration;
@@ -21,6 +22,7 @@ public static class Extensions
         /// <param name="services">Current list of services</param>
         /// <param name="configure">Configuration</param>
         /// <returns>Services</returns>
+        [ExcludeFromCodeCoverage]
         public static IServiceCollection AddAzureMapsControl(this IServiceCollection services, Action<AzureMapsConfiguration> configure)
         {
             services

tests/AzureMapsControl.Components.Tests/Configuration/AzureMapsConfiguration.cs

@@ -1,6 +1,7 @@
 namespace AzureMapsControl.Components.Tests.Configuration
 {
     using AzureMapsControl.Components.Configuration;
+    using AzureMapsControl.Components.Tests.Json;
 
     using Xunit;
 
@@ -51,4 +52,59 @@ public void Should_NotHaveAnAuthType()
             Assert.False(configuration.Validate());
         }
     }
+
+    public class AzureMapsConfigurationJsonConverterTests : JsonConverterTests<AzureMapsConfiguration>
+    {
+        public AzureMapsConfigurationJsonConverterTests() : base(new AzureMapsConfigurationJsonConverter())
+        {
+        }
+
+        [Fact]
+        public void Should_Write_WithSubscriptionKey()
+        {
+            var configuration = new AzureMapsConfiguration {
+                SubscriptionKey = "subKey"
+            };
+            var expectedJson = "{"
+                + "\"authType\":\"" + configuration.AuthType + "\","
+                + "\"subscriptionKey\":\"" + configuration.SubscriptionKey + "\""
+                + "}";
+
+            TestAndAssertWrite(configuration, expectedJson);
+        }
+
+        [Fact]
+        public void Should_Write_WithAad()
+        {
+            var configuration = new AzureMapsConfiguration {
+                AadAppId = "appId",
+                AadTenant = "tenant",
+                ClientId = "client"
+            };
+
+            var expectedJson = "{"
+                + "\"authType\":\"" + configuration.AuthType + "\","
+                + "\"aadAppId\":\"" + configuration.AadAppId + "\","
+                + "\"aadTenant\":\"" + configuration.AadTenant + "\","
+                + "\"clientId\":\"" + configuration.ClientId + "\""
+                + "}";
+
+            TestAndAssertWrite(configuration, expectedJson);
+        }
+
+        [Fact]
+        public void Should_Write_WithAnonymous()
+        {
+            var configuration = new AzureMapsConfiguration {
+                ClientId = "client"
+            };
+
+            var expectedJson = "{"
+                + "\"authType\":\"" + configuration.AuthType + "\","
+                + "\"clientId\":\"" + configuration.ClientId + "\""
+                + "}";
+
+            TestAndAssertWrite(configuration, expectedJson);
+        }
+    }
 }

tests/AzureMapsControl.Components.Tests/Runtime/MapJsRuntime.cs

@@ -0,0 +1,49 @@
+namespace AzureMapsControl.Components.Tests.Runtime
+{
+    using System.Threading.Tasks;
+    using AzureMapsControl.Components.Runtime;
+
+    using Microsoft.Extensions.Logging;
+    using Microsoft.JSInterop;
+
+    using Moq;
+
+    using Xunit;
+
+    public class MapJsRuntimeTests
+    {
+        private readonly Mock<IJSRuntime> _jsRuntimeMock = new Mock<IJSRuntime>();
+        private readonly Mock<ILogger<MapJsRuntime>> _loggerMock = new Mock<ILogger<MapJsRuntime>>();
+
+        private readonly MapJsRuntime _sut;
+
+        public MapJsRuntimeTests() => _sut = new(_jsRuntimeMock.Object, _loggerMock.Object);
+
+        [Fact]
+        public async Task Should_InvokeVoidAsync()
+        {
+            var identifier = "identifier";
+            var args = new object[] { 1, 2 };
+
+            await _sut.InvokeVoidAsync(identifier, args);
+
+            _jsRuntimeMock.Verify(runtime => runtime.InvokeAsync<Microsoft.JSInterop.Infrastructure.IJSVoidResult>(identifier, args), Times.Once);
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+
+        [Fact]
+        public async Task Should_InvokeAsync()
+        {
+            var identifier = "identifier";
+            var args = new object[] { 1, 2 };
+            var expected = "expected";
+            _jsRuntimeMock.Setup(runtime => runtime.InvokeAsync<string>(identifier, args)).ReturnsAsync(expected).Verifiable();
+
+            var result = await _sut.InvokeAsync<string>(identifier, args);
+
+            Assert.Equal(expected, result);
+            _jsRuntimeMock.Verify();
+            _jsRuntimeMock.VerifyNoOtherCalls();
+        }
+    }
+}

tests/AzureMapsControl.Components.Tests/Traffic/TrafficOptions.cs

@@ -0,0 +1,75 @@
+namespace AzureMapsControl.Components.Tests.Traffic
+{
+    using AzureMapsControl.Components.Tests.Json;
+    using AzureMapsControl.Components.Traffic;
+
+    using Xunit;
+
+    public class TrafficOptionsJsonConverterTests : JsonConverterTests<TrafficOptions>
+    {
+        public TrafficOptionsJsonConverterTests() : base(new TrafficOptionsJsonConverter()) { }
+
+        [Fact]
+        public void Should_ReadTrafficFlow()
+        {
+            var json = "{"
+                + "\"flow\":\"" + TrafficFlow.Relative.ToString() + "\""
+                + "}";
+            var result = Read(json);
+            Assert.Equal(TrafficFlow.Relative, result.Flow);
+            Assert.Null(result.Incidents);
+        }
+
+        [Fact]
+        public void Should_ReadIncidents()
+        {
+            var json = "{"
+                + "\"incidents\":true"
+                + "}";
+            var result = Read(json);
+            Assert.True(result.Incidents);
+        }
+
+        [Fact]
+        public void Should_ReadTrafficOptions()
+        {
+            var json = "{"
+                + "\"flow\":\"" + TrafficFlow.Relative.ToString() + "\","
+                + "\"incidents\":true"
+                + "}";
+            var result = Read(json);
+            Assert.Equal(TrafficFlow.Relative, result.Flow);
+            Assert.True(result.Incidents);
+        }
+
+        [Fact]
+        public async void Should_WriteTrafficOptions()
+        {
+            var trafficOptions = new TrafficOptions {
+                Flow = TrafficFlow.Relative
+            };
+
+            var expectedJson = "{"
+                + "\"flow\":\"" + trafficOptions.Flow.ToString() + "\""
+                + "}";
+
+            TestAndAssertWrite(trafficOptions, expectedJson);
+        }
+
+        [Fact]
+        public async void Should_WriteTrafficOptions_WithIncidents()
+        {
+            var trafficOptions = new TrafficOptions {
+                Flow = TrafficFlow.Relative,
+                Incidents = true
+            };
+
+            var expectedJson = "{"
+                + "\"flow\":\"" + trafficOptions.Flow.ToString() + "\","
+                + "\"incidents\":true"
+                + "}";
+
+            TestAndAssertWrite(trafficOptions, expectedJson);
+        }
+    }
+}