adding support for ExpectInstance in DependencyValidator

brettsam · brettsam · commit 6939a3386aa2 · 2019-10-01T06:16:57.000-07:00
diff --git a/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/DependencyValidator.cs b/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/DependencyValidator.cs
@@ -88,7 +88,7 @@ private static string FormatServiceDescriptor(ServiceDescriptor descriptor)
 
             if (descriptor.ImplementationInstance != null)
             {
-                format += $", {nameof(descriptor.ImplementationInstance)}: {descriptor.ImplementationInstance}";
+                format += $", {nameof(descriptor.ImplementationInstance)}: {descriptor.ImplementationInstance.GetType()}";
             }
 
             if (descriptor.ImplementationType != null)
diff --git a/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ExpectedDependencyBuilder.cs b/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ExpectedDependencyBuilder.cs
@@ -68,6 +68,13 @@ public void ExpectNone<TService>()
             AddNewMatch<TService>(match);
         }
 
+        public void ExpectInstance<TService, TExpectedType>()
+        {
+            ServiceMatch match = ServiceMatch.CreateMatch<TService>();
+            AddNewMatch<TService>(match);
+            match.AddInstance<TExpectedType>();
+        }
+
         public ExpectedCollectionBuilder ExpectCollection<TService>()
         {
             ServiceMatch match = ServiceMatch.CreateCollectionMatch<TService>();
diff --git a/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ServiceMatch.cs b/src/WebJobs.Script.WebHost/DependencyInjection/DependencyValidator/ServiceMatch.cs
@@ -108,6 +108,13 @@ public void AddFactory<TFactoryType>(ServiceLifetime lifetime)
             Add(desc);
         }
 
+        public void AddInstance<TInstanceType>()
+        {
+            // Hijack the instance property pass in the expected type
+            ServiceDescriptor desc = new ServiceDescriptor(ServiceType, typeof(TInstanceType));
+            Add(desc);
+        }
+
         private void Add(ServiceDescriptor desc)
         {
             if (_match == MatchType.Single && _requiredDescriptors.Any())
@@ -168,7 +175,8 @@ public IEnumerable<InvalidServiceDescriptor> FindInvalidServices(IServiceCollect
 
         private static bool IsMatch(ServiceDescriptor expected, ServiceDescriptor registered)
         {
-            bool factoryMatches = false;
+            bool factoryMatches = expected.ImplementationFactory == registered.ImplementationFactory;
+            bool instanceMatches = expected.ImplementationInstance == registered.ImplementationInstance;
 
             if (expected.ImplementationFactory != null && registered.ImplementationFactory != null)
             {
@@ -178,13 +186,16 @@ private static bool IsMatch(ServiceDescriptor expected, ServiceDescriptor regist
                 Assembly expectedAssembly = (Assembly)expected.ImplementationFactory(null);
                 factoryMatches = expectedAssembly == registered.ImplementationFactory.GetMethodInfo().DeclaringType.Assembly;
             }
-            else
+            else if (expected.ImplementationInstance != null && registered.ImplementationInstance != null)
             {
-                factoryMatches = expected.ImplementationFactory == registered.ImplementationFactory;
+                // A non-null ImplementationInstance signals we expect this to be an Instance, and we've
+                // stored the type we expect in the expected ServiceDescriptor.
+                Type expectedInstanceType = expected.ImplementationInstance as Type;
+                instanceMatches = expectedInstanceType == registered.ImplementationInstance.GetType();
             }
 
             return factoryMatches &&
-                expected.ImplementationInstance == registered.ImplementationInstance &&
+                instanceMatches &&
                 expected.ImplementationType == registered.ImplementationType &&
                 expected.Lifetime == registered.Lifetime &&
                 expected.ServiceType == registered.ServiceType;
diff --git a/test/WebJobs.Script.Tests/Configuration/DefaultDependencyValidatorTests.cs b/test/WebJobs.Script.Tests/Configuration/DefaultDependencyValidatorTests.cs
@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Hosting;
+using Microsoft.Azure.WebJobs.Script.Diagnostics;
 using Microsoft.Azure.WebJobs.Script.Eventing;
 using Microsoft.Azure.WebJobs.Script.WebHost;
 using Microsoft.Azure.WebJobs.Script.WebHost.DependencyInjection;
@@ -39,6 +40,7 @@ public async Task Validator_InvalidServices_LogsError()
             {
                 s.AddSingleton<IHostedService, MyHostedService>();
                 s.AddSingleton<IScriptEventManager, MyScriptEventManager>();
+                s.AddSingleton<IMetricsLogger>(new MyMetricsLogger());
 
                 // Try removing system logger
                 var descriptor = s.Single(p => p.ImplementationType == typeof(SystemLoggerProvider));
@@ -48,9 +50,10 @@ public async Task Validator_InvalidServices_LogsError()
             Assert.NotNull(invalidServicesMessage);
 
             IEnumerable<string> messageLines = invalidServicesMessage.Exception.Message.Split(Environment.NewLine, StringSplitOptions.RemoveEmptyEntries).Select(p => p.Trim());
-            Assert.Equal(4, messageLines.Count());
+            Assert.Equal(5, messageLines.Count());
             Assert.Contains(messageLines, p => p.StartsWith("[Invalid]") && p.EndsWith(nameof(MyHostedService)));
             Assert.Contains(messageLines, p => p.StartsWith("[Invalid]") && p.EndsWith(nameof(MyScriptEventManager)));
+            Assert.Contains(messageLines, p => p.StartsWith("[Invalid]") && p.EndsWith(nameof(MyMetricsLogger)));
             Assert.Contains(messageLines, p => p.StartsWith("[Missing]") && p.EndsWith(nameof(SystemLoggerProvider)));
         }
 
@@ -79,13 +82,6 @@ private async Task<LogMessage> RunTest(Action<IServiceCollection> configureWebHo
                     })
                     .ConfigureServices(s =>
                     {
-                        s.AddSingleton<IConfigureBuilder<ILoggingBuilder>>(new DelegatedConfigureBuilder<ILoggingBuilder>(b =>
-                        {
-                            b.AddProvider(loggerProvider);
-
-                            configureJobHost?.Invoke(b.Services);
-                        }));
-
                         string uniqueTestRootPath = Path.Combine(Path.GetTempPath(), "FunctionsTest", "DependencyValidatorTests");
 
                         s.PostConfigureAll<ScriptApplicationHostOptions>(o =>
@@ -97,6 +93,14 @@ private async Task<LogMessage> RunTest(Action<IServiceCollection> configureWebHo
                         });
 
                         configureWebHost?.Invoke(s);
+                    })
+                    .ConfigureScriptHostLogging(b =>
+                    {
+                        b.AddProvider(loggerProvider);
+                    })
+                    .ConfigureScriptHostServices(b =>
+                    {
+                        configureJobHost?.Invoke(b);
                     });
 
             using (var host = builder.Build())
@@ -143,6 +147,31 @@ public IDisposable Subscribe(IObserver<ScriptEvent> observer)
             }
         }
 
+        private class MyMetricsLogger : IMetricsLogger
+        {
+            public object BeginEvent(string eventName, string functionName = null, string data = null) => null;
+
+            public void BeginEvent(MetricEvent metricEvent)
+            {
+            }
+
+            public void EndEvent(MetricEvent metricEvent)
+            {
+            }
+
+            public void EndEvent(object eventHandle)
+            {
+            }
+
+            public void LogEvent(MetricEvent metricEvent)
+            {
+            }
+
+            public void LogEvent(string eventName, string functionName = null, string data = null)
+            {
+            }
+        }
+
         private class TestScriptHostBuilder : IScriptHostBuilder
         {
             private readonly DefaultScriptHostBuilder _builder;
diff --git a/test/WebJobs.Script.Tests/Configuration/ExpectedDependencyBuilderTests.cs b/test/WebJobs.Script.Tests/Configuration/ExpectedDependencyBuilderTests.cs
@@ -58,6 +58,67 @@ public void ExpectSingle_Factory()
             Assert.Empty(invalidDescriptors);
         }
 
+        [Fact]
+        public void ExpectInstance()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<ITestSomething>(new TestSomethingA());
+            services.AddSingleton<ITestSomething>(new TestSomethingB());
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+            validator.ExpectInstance<ITestSomething, TestSomethingB>();
+
+            var invalidDescriptors = validator.FindInvalidServices(services);
+            Assert.Empty(invalidDescriptors);
+        }
+
+        [Fact]
+        public void ExpectInstance_Fail()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<ITestSomething>(new TestSomethingA());
+            services.AddSingleton<ITestSomething>(new TestSomethingB());
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+            validator.ExpectInstance<ITestSomething, TestSomethingA>();
+
+            var invalidDescriptor = validator.FindInvalidServices(services).Single();
+            Assert.Equal(typeof(ITestSomething), invalidDescriptor.Descriptor.ServiceType);
+            Assert.Equal(typeof(TestSomethingB), invalidDescriptor.Descriptor.ImplementationInstance.GetType());
+        }
+
+        [Fact]
+        public void ExpectInstance_FailWithFactory()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<ITestSomething>(_ => new TestSomethingA());
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+            validator.ExpectInstance<ITestSomething, TestSomethingA>();
+
+            var invalidDescriptor = validator.FindInvalidServices(services).Single();
+            Assert.Equal(typeof(ITestSomething), invalidDescriptor.Descriptor.ServiceType);
+            Assert.Null(invalidDescriptor.Descriptor.ImplementationInstance);
+            Assert.Null(invalidDescriptor.Descriptor.ImplementationType);
+            Assert.NotNull(invalidDescriptor.Descriptor.ImplementationFactory);
+        }
+
+        [Fact]
+        public void ExpectInstance_FailWithReflection()
+        {
+            ServiceCollection services = new ServiceCollection();
+            services.AddSingleton<ITestSomething, TestSomethingA>();
+
+            ExpectedDependencyBuilder validator = new ExpectedDependencyBuilder();
+            validator.ExpectInstance<ITestSomething, TestSomethingA>();
+
+            var invalidDescriptor = validator.FindInvalidServices(services).Single();
+            Assert.Equal(typeof(ITestSomething), invalidDescriptor.Descriptor.ServiceType);
+            Assert.Null(invalidDescriptor.Descriptor.ImplementationInstance);
+            Assert.Null(invalidDescriptor.Descriptor.ImplementationFactory);
+            Assert.NotNull(invalidDescriptor.Descriptor.ImplementationType);
+        }
+
         [Fact]
         public void ExpectSingle_Type_Fail()
         {

Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ private static string FormatServiceDescriptor(ServiceDescriptor descriptor)`
`88`	`88`
`89`	`89`	`if (descriptor.ImplementationInstance != null)`
`90`	`90`	`{`
`91`		`- format += $", {nameof(descriptor.ImplementationInstance)}: {descriptor.ImplementationInstance}";`
	`91`	`+ format += $", {nameof(descriptor.ImplementationInstance)}: {descriptor.ImplementationInstance.GetType()}";`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`if (descriptor.ImplementationType != null)`
Original file line number	Diff line number	Diff line change
`@@ -68,6 +68,13 @@ public void ExpectNone<TService>()`
`68`	`68`	`AddNewMatch<TService>(match);`
`69`	`69`	`}`
`70`	`70`
	`71`	`+ public void ExpectInstance<TService, TExpectedType>()`
	`72`	`+ {`
	`73`	`+ ServiceMatch match = ServiceMatch.CreateMatch<TService>();`
	`74`	`+ AddNewMatch<TService>(match);`
	`75`	`+ match.AddInstance<TExpectedType>();`
	`76`	`+ }`
	`77`	`+`
`71`	`78`	`public ExpectedCollectionBuilder ExpectCollection<TService>()`
`72`	`79`	`{`
`73`	`80`	`ServiceMatch match = ServiceMatch.CreateCollectionMatch<TService>();`
Original file line number	Diff line number	Diff line change
`@@ -108,6 +108,13 @@ public void AddFactory<TFactoryType>(ServiceLifetime lifetime)`
`108`	`108`	`Add(desc);`
`109`	`109`	`}`
`110`	`110`
	`111`	`+ public void AddInstance<TInstanceType>()`
	`112`	`+ {`
	`113`	`+ // Hijack the instance property pass in the expected type`
	`114`	`+ ServiceDescriptor desc = new ServiceDescriptor(ServiceType, typeof(TInstanceType));`
	`115`	`+ Add(desc);`
	`116`	`+ }`
	`117`	`+`
`111`	`118`	`private void Add(ServiceDescriptor desc)`
`112`	`119`	`{`
`113`	`120`	`if (_match == MatchType.Single && _requiredDescriptors.Any())`
`@@ -168,7 +175,8 @@ public IEnumerable<InvalidServiceDescriptor> FindInvalidServices(IServiceCollect`
`168`	`175`
`169`	`176`	`private static bool IsMatch(ServiceDescriptor expected, ServiceDescriptor registered)`
`170`	`177`	`{`
`171`		`- bool factoryMatches = false;`
	`178`	`+ bool factoryMatches = expected.ImplementationFactory == registered.ImplementationFactory;`
	`179`	`+ bool instanceMatches = expected.ImplementationInstance == registered.ImplementationInstance;`
`172`	`180`
`173`	`181`	`if (expected.ImplementationFactory != null && registered.ImplementationFactory != null)`
`174`	`182`	`{`
`@@ -178,13 +186,16 @@ private static bool IsMatch(ServiceDescriptor expected, ServiceDescriptor regist`
`178`	`186`	`Assembly expectedAssembly = (Assembly)expected.ImplementationFactory(null);`
`179`	`187`	`factoryMatches = expectedAssembly == registered.ImplementationFactory.GetMethodInfo().DeclaringType.Assembly;`
`180`	`188`	`}`
`181`		`- else`
	`189`	`+ else if (expected.ImplementationInstance != null && registered.ImplementationInstance != null)`
`182`	`190`	`{`
`183`		`- factoryMatches = expected.ImplementationFactory == registered.ImplementationFactory;`
	`191`	`+ // A non-null ImplementationInstance signals we expect this to be an Instance, and we've`
	`192`	`+ // stored the type we expect in the expected ServiceDescriptor.`
	`193`	`+ Type expectedInstanceType = expected.ImplementationInstance as Type;`
	`194`	`+ instanceMatches = expectedInstanceType == registered.ImplementationInstance.GetType();`
`184`	`195`	`}`
`185`	`196`
`186`	`197`	`return factoryMatches &&`
`187`		`- expected.ImplementationInstance == registered.ImplementationInstance &&`
	`198`	`+ instanceMatches &&`
`188`	`199`	`expected.ImplementationType == registered.ImplementationType &&`
`189`	`200`	`expected.Lifetime == registered.Lifetime &&`
`190`	`201`	`expected.ServiceType == registered.ServiceType;`