Added tests that validate the IoC container is configured correctly

test/JsonApiDotNetCoreExampleTests/UnitTests/Configuration/DependencyContainerRegistrationTests.cs

@@ -0,0 +1,122 @@
+using System;
+using FluentAssertions;
+using JetBrains.Annotations;
+using JsonApiDotNetCore;
+using JsonApiDotNetCoreExample.Startups;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Hosting;
+using Xunit;
+
+namespace JsonApiDotNetCoreExampleTests.UnitTests.Configuration
+{
+    public sealed class DependencyContainerRegistrationTests
+    {
+        [Fact]
+        public void Can_resolve_registered_services_from_example_project()
+        {
+            // Arrange
+            IHostBuilder hostBuilder = CreateValidatingHostBuilder();
+
+            // Act
+            using IHost _ = hostBuilder.Build();
+        }
+
+        [Fact]
+        public void Cannot_resolve_registered_services_with_conflicting_scopes()
+        {
+            // Arrange
+            IHostBuilder hostBuilder = CreateValidatingHostBuilder();
+
+            hostBuilder.ConfigureServices(services =>
+            {
+                services.AddScoped<SomeScopedService>();
+                services.AddSingleton<SomeSingletonService>();
+            });
+
+            // Act
+            Action action = () =>
+            {
+                using IHost _ = hostBuilder.Build();
+            };
+
+            // Assert
+            action.Should().ThrowExactly<AggregateException>().WithMessage("Some services are not able to be constructed * " +
+                "Singleton * Cannot consume scoped service *");
+        }
+
+        [Fact]
+        public void Cannot_resolve_registered_services_with_circular_dependency()
+        {
+            // Arrange
+            IHostBuilder hostBuilder = CreateValidatingHostBuilder();
+
+            hostBuilder.ConfigureServices(services =>
+            {
+                services.AddScoped<CircularServiceA>();
+                services.AddScoped<CircularServiceB>();
+            });
+
+            // Act
+            Action action = () =>
+            {
+                using IHost _ = hostBuilder.Build();
+            };
+
+            // Assert
+            action.Should().ThrowExactly<AggregateException>().WithMessage("Some services are not able to be constructed * " +
+                "A circular dependency was detected *");
+        }
+
+        private static IHostBuilder CreateValidatingHostBuilder()
+        {
+            IHostBuilder hostBuilder = Host.CreateDefaultBuilder().ConfigureWebHostDefaults(webBuilder =>
+            {
+                webBuilder.UseStartup<Startup>();
+
+                webBuilder.UseDefaultServiceProvider(options =>
+                {
+                    options.ValidateScopes = true;
+                    options.ValidateOnBuild = true;
+                });
+            });
+
+            return hostBuilder;
+        }
+
+        [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+        private sealed class SomeSingletonService
+        {
+            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
+            public SomeSingletonService(SomeScopedService scopedService)
+            {
+                ArgumentGuard.NotNull(scopedService, nameof(scopedService));
+            }
+        }
+
+        [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+        private sealed class SomeScopedService
+        {
+        }
+
+        [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+        private sealed class CircularServiceA
+        {
+            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
+            public CircularServiceA(CircularServiceB serviceB)
+            {
+                ArgumentGuard.NotNull(serviceB, nameof(serviceB));
+            }
+        }
+
+        [UsedImplicitly(ImplicitUseKindFlags.InstantiatedNoFixedConstructorSignature)]
+        private sealed class CircularServiceB
+        {
+            // ReSharper disable once ParameterOnlyUsedForPreconditionCheck.Local
+            public CircularServiceB(CircularServiceA serviceA)
+            {
+                ArgumentGuard.NotNull(serviceA, nameof(serviceA));
+            }
+        }
+    }
+}