Beispiel #1
0
        public void CurrentCachesResolverResult()
        {
            // Arrange
            TestProvider providerFromDefaultValue    = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();

            Mock <IDependencyResolver> resolver = new Mock <IDependencyResolver>();

            resolver
            .Setup(r => r.GetService(typeof(TestProvider)))
            .Returns(providerFromServiceLocation);

            SingleServiceResolver <TestProvider> singleResolver =
                new SingleServiceResolver <TestProvider>(
                    () => null,
                    providerFromDefaultValue,
                    resolver.Object,
                    "TestProvider.Current"
                    );

            // Act
            TestProvider returnedProvider = singleResolver.Current;
            TestProvider cachedProvider   = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromServiceLocation, returnedProvider);
            Assert.Equal(providerFromServiceLocation, cachedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)), Times.Exactly(1));
        }
Beispiel #2
0
        public void CurrentThrowsIfCurrentSetThroughServiceAndSetter()
        {
            // Arrange
            TestProvider providerFromCurrentValueThunk = new TestProvider();
            TestProvider providerFromServiceLocation   = new TestProvider();
            TestProvider providerFromDefaultValue      = new TestProvider();
            Mock <IDependencyResolver> resolver        = new Mock <IDependencyResolver>();

            resolver
            .Setup(r => r.GetService(typeof(TestProvider)))
            .Returns(providerFromServiceLocation);

            SingleServiceResolver <TestProvider> singleResolver =
                new SingleServiceResolver <TestProvider>(
                    () => providerFromCurrentValueThunk,
                    providerFromDefaultValue,
                    resolver.Object,
                    "TestProvider.Current"
                    );

            //Act & assert
            Assert.Throws <InvalidOperationException>(
                () => singleResolver.Current,
                "An instance of TestProvider was found in the resolver as well as a custom registered provider in TestProvider.Current. Please set only one or the other."
                );
        }
Beispiel #3
0
 internal ControllerBuilder(IResolver <IControllerFactory> serviceResolver)
 {
     if (serviceResolver == null)
     {
         serviceResolver = new SingleServiceResolver <IControllerFactory>(() => this._factoryThunk(),
                                                                          new DefaultControllerFactory()
         {
             ControllerBuilder = this
         },
                                                                          "ControllerBuilder.GetControllerFactory");
     }
     this._serviceResolver = serviceResolver;
 }
Beispiel #4
0
        public void CurrentPropagatesExceptionWhenResolverThrowsNonActivationException()
        {
            // Arrange
            TestProvider providerFromDefaultValue               = new TestProvider();
            Mock <IDependencyResolver>           resolver       = new Mock <IDependencyResolver>(MockBehavior.Strict);
            SingleServiceResolver <TestProvider> singleResolver = new SingleServiceResolver <TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act & Assert
            Assert.Throws <MockException>(
                () => singleResolver.Current,
                @"IDependencyResolver.GetService(System.Web.Mvc.Test.SingleServiceResolverTest+TestProvider) invocation failed with mock behavior Strict.
All invocations on the mock must have a corresponding setup."
                );
        }
Beispiel #5
0
        public void CurrentReturnsDefaultIfCurrentNotSet()
        {
            //Arrange
            TestProvider providerFromDefaultValue               = new TestProvider();
            Mock <IDependencyResolver>           resolver       = new Mock <IDependencyResolver>();
            SingleServiceResolver <TestProvider> singleResolver = new SingleServiceResolver <TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            //Act
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(returnedProvider, providerFromDefaultValue);
            resolver.Verify(l => l.GetService(typeof(TestProvider)));
        }
 /// <summary>
 /// 创建 DefaultControllerFactory 实例
 /// </summary>
 /// <param name="controllerActivator"></param>
 /// <param name="activatorResolver"></param>
 /// <param name="dependencyResolver"></param>
 internal DefaultControllerFactory(IControllerActivator controllerActivator, IResolver <IControllerActivator> activatorResolver, IDependencyResolver dependencyResolver)
 {
     if (controllerActivator != null)
     {
         this._controllerActivator = controllerActivator;
         return;
     }
     if (activatorResolver == null)
     {
         activatorResolver = new SingleServiceResolver <IControllerActivator>(() => null,
                                                                              new DefaultControllerFactory.DefaultControllerActivator(dependencyResolver), "DefaultControllerFactory contstructor");
     }
     this._activatorResolver = activatorResolver;
 }
        public void CurrentReturnsCurrentProviderNotDefaultIfSet() {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromCurrentValueThunk = null;
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            providerFromCurrentValueThunk = new TestProvider();
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.AreEqual(providerFromCurrentValueThunk, returnedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)));
        }
Beispiel #8
0
        public void CurrentReturnsCurrentProviderNotDefaultIfSet()
        {
            // Arrange
            TestProvider providerFromDefaultValue               = new TestProvider();
            TestProvider providerFromCurrentValueThunk          = null;
            Mock <IDependencyResolver>           resolver       = new Mock <IDependencyResolver>();
            SingleServiceResolver <TestProvider> singleResolver = new SingleServiceResolver <TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            providerFromCurrentValueThunk = new TestProvider();
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromCurrentValueThunk, returnedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)));
        }
Beispiel #9
0
        public void CurrentDoesNotQueryResolverAfterReceivingNull()
        {
            // Arrange
            TestProvider providerFromDefaultValue               = new TestProvider();
            TestProvider providerFromCurrentValueThunk          = new TestProvider();
            Mock <IDependencyResolver>           resolver       = new Mock <IDependencyResolver>();
            SingleServiceResolver <TestProvider> singleResolver = new SingleServiceResolver <TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;
            TestProvider cachedProvider   = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromCurrentValueThunk, returnedProvider);
            Assert.Equal(providerFromCurrentValueThunk, cachedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)), Times.Exactly(1));
        }
        public void CurrentPropagatesExceptionWhenResolverThrowsNonActivationException()
        {
            // Arrange
            TestProvider providerFromDefaultValue               = new TestProvider();
            Mock <IDependencyResolver>           resolver       = new Mock <IDependencyResolver>(MockBehavior.Strict);
            SingleServiceResolver <TestProvider> singleResolver = new SingleServiceResolver <TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act & Assert
            var ex = Assert.Throws <MockException>(() => singleResolver.Current);

            Assert.Equal(
                "IDependencyResolver.GetService(System.Web.Mvc.Test.SingleServiceResolverTest+TestProvider) invocation failed with mock behavior Strict." +
                Environment.NewLine +
                "All invocations on the mock must have a corresponding setup.",
                ex.Message,
                ignoreLineEndingDifferences: true);
        }
        public void CurrentConsultsResolver() {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();

            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            resolver.Setup(r => r.GetService(typeof(TestProvider)))
                    .Returns(providerFromServiceLocation);

            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.AreEqual(providerFromServiceLocation, returnedProvider);
        }
        public void CurrentDoesNotQueryResolverAfterReceivingNull()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            TestProvider providerFromCurrentValueThunk = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act
            TestProvider returnedProvider = singleResolver.Current;
            TestProvider cachedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(providerFromCurrentValueThunk, returnedProvider);
            Assert.Equal(providerFromCurrentValueThunk, cachedProvider);
            resolver.Verify(r => r.GetService(typeof(TestProvider)), Times.Exactly(1));
        }
        public void CurrentPropagatesExceptionWhenResolverThrowsNonActivationException()
        {
            // Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>(MockBehavior.Strict);
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            // Act & Assert
            Assert.Throws<MockException>(
                () => singleResolver.Current,
                @"IDependencyResolver.GetService(System.Web.Mvc.Test.SingleServiceResolverTest+TestProvider) invocation failed with mock behavior Strict.
All invocations on the mock must have a corresponding setup."
                );
        }
        public void CurrentThrowsIfCurrentSetThroughServiceAndSetter()
        {
            // Arrange
            TestProvider providerFromCurrentValueThunk = new TestProvider();
            TestProvider providerFromServiceLocation = new TestProvider();
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();

            resolver.Setup(r => r.GetService(typeof(TestProvider)))
                .Returns(providerFromServiceLocation);

            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => providerFromCurrentValueThunk, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            //Act & assert
            Assert.Throws<InvalidOperationException>(
                () => singleResolver.Current,
                "An instance of TestProvider was found in the resolver as well as a custom registered provider in TestProvider.Current. Please set only one or the other."
                );
        }
        public void CurrentReturnsDefaultIfCurrentNotSet()
        {
            //Arrange
            TestProvider providerFromDefaultValue = new TestProvider();
            Mock<IDependencyResolver> resolver = new Mock<IDependencyResolver>();
            SingleServiceResolver<TestProvider> singleResolver = new SingleServiceResolver<TestProvider>(() => null, providerFromDefaultValue, resolver.Object, "TestProvider.Current");

            //Act
            TestProvider returnedProvider = singleResolver.Current;

            // Assert
            Assert.Equal(returnedProvider, providerFromDefaultValue);
            resolver.Verify(l => l.GetService(typeof(TestProvider)));
        }