public void RootResolver_returns_the_root_resolver()
            {
                var rootResolver = new RootDependencyResolver();

                var config = new InternalConfiguration(new Mock <ResolverChain>().Object, new Mock <ResolverChain>().Object, rootResolver);

                Assert.Same(rootResolver, config.RootResolver);
            }
示例#2
0
        internal DbConfiguration(ResolverChain appConfigChain, ResolverChain normalResolverChain, RootDependencyResolver rootResolver)
        {
            Contract.Requires(appConfigChain != null);
            Contract.Requires(normalResolverChain != null);

            _rootResolver = rootResolver;
            _resolvers = new CompositeResolver<ResolverChain, ResolverChain>(appConfigChain, normalResolverChain);
            _resolvers.Second.Add(_rootResolver);
        }
示例#3
0
        public InternalConfiguration(ResolverChain appConfigChain, ResolverChain normalResolverChain, RootDependencyResolver rootResolver)
        {
            DebugCheck.NotNull(appConfigChain);
            DebugCheck.NotNull(normalResolverChain);

            _rootResolver = rootResolver;
            _resolvers    = new CompositeResolver <ResolverChain, ResolverChain>(appConfigChain, normalResolverChain);
            _resolvers.Second.Add(_rootResolver);
        }
 public InternalConfiguration(
     ResolverChain appConfigChain                  = null,
     ResolverChain normalResolverChain             = null,
     RootDependencyResolver rootResolver           = null,
     AppConfigDependencyResolver appConfigResolver = null)
 {
     _rootResolver = rootResolver ?? new RootDependencyResolver();
     _resolvers    = new CompositeResolver <ResolverChain, ResolverChain>(appConfigChain ?? new ResolverChain(), normalResolverChain ?? new ResolverChain());
     _resolvers.Second.Add(_rootResolver);
     _resolvers.First.Add(appConfigResolver ?? new AppConfigDependencyResolver(AppConfig.DefaultInstance, this));
 }
        public void GetService_can_be_accessed_from_multiple_threads_concurrently()
        {
            for (var i = 0; i < 30; i++)
            {
                var bag = new ConcurrentBag <DbProviderServices>();

                var resolver = new RootDependencyResolver();

                ExecuteInParallel(() => bag.Add(resolver.GetService <DbProviderServices>("System.Data.SqlClient")));

                Assert.Equal(20, bag.Count);
                Assert.True(bag.All(c => SqlProviderServices.Instance == c));
            }
        }
示例#6
0
        public void GetService_can_be_accessed_from_multiple_threads_concurrently()
        {
            for (var i = 0; i < 30; i++)
            {
                var bag = new ConcurrentBag <AttributeProvider>();

                var resolver = new RootDependencyResolver();

                ExecuteInParallel(() => bag.Add(resolver.GetService <AttributeProvider>()));

                Assert.Equal(20, bag.Count);
                Assert.True(bag.All(c => c.GetType() == typeof(AttributeProvider)));
            }
        }
        public void The_root_resolver_uses_the_default_provider_services_resolver_and_caches_provider_instances()
        {
            var providerServices = new Mock<DbProviderServices>().Object;
            var mockProviderResolver = new Mock<DefaultProviderServicesResolver>();
            mockProviderResolver
                .Setup(m => m.GetService(typeof(DbProviderServices), "FooClient"))
                .Returns(providerServices);

            var resolver = new RootDependencyResolver(new MigrationsConfigurationResolver(), mockProviderResolver.Object);

            Assert.Same(providerServices, resolver.GetService<DbProviderServices>("FooClient"));
            mockProviderResolver.Verify(m => m.GetService(typeof(DbProviderServices), "FooClient"), Times.Once());
            Assert.Same(providerServices, resolver.GetService<DbProviderServices>("FooClient"));
            mockProviderResolver.Verify(m => m.GetService(typeof(DbProviderServices), "FooClient"), Times.Once());
        }
        /// <summary>
        ///     This method is not thread-safe and should only be used to switch in a different root resolver
        ///     before the configuration is locked and set. It is used for pushing a new configuration by
        ///     DbContextInfo while maintaining legacy settings (such as database initializers) that are
        ///     set on the root resolver.
        /// </summary>
        public virtual void SwitchInRootResolver(RootDependencyResolver value)
        {
            DebugCheck.NotNull(value);

            Debug.Assert(!_isLocked);

            // The following is not thread-safe but this code is only called when pushing a configuration
            // and happens to a new DbConfiguration before it has been set and locked.
            var newChain = new ResolverChain();

            newChain.Add(value);
            _resolvers.Second.Resolvers.Skip(1).Each(newChain.Add);

            _rootResolver = value;
            _resolvers    = new CompositeResolver <ResolverChain, ResolverChain>(_resolvers.First, newChain);
        }
        public void The_root_resolver_can_return_a_default_history_context_factory_that_creates_HistoryContext_instances()
        {
            var factory =
                new RootDependencyResolver(new DefaultProviderServicesResolver(), new DatabaseInitializerResolver())
                    .GetService<HistoryContextFactory>();
            
            Assert.IsType<HistoryContextFactory>(factory);

            using (var connection = new SqlConnection())
            {
                using (var context = factory(connection, null))
                {
                    Assert.IsType<HistoryContext>(context);
                }
            }
        }
        public void GetService_can_be_accessed_from_multiple_threads_concurrently()
        {
            for (var i = 0; i < 30; i++)
            {
                var bag = new ConcurrentBag<DbProviderServices>();

                var resolver = new RootDependencyResolver(
                    new MigrationsConfigurationResolver(),
                    new DefaultProviderServicesResolver());

                ExecuteInParallel(() => bag.Add(resolver.GetService<DbProviderServices>("System.Data.SqlClient")));

                Assert.Equal(20, bag.Count);
                Assert.True(bag.All(c => SqlProviderServices.Instance == c));
            }
        }
示例#11
0
        public void The_root_resolver_can_return_a_default_history_context_factory_that_creates_HistoryContext_instances()
        {
            var factory =
                new RootDependencyResolver(new DefaultProviderServicesResolver(), new DatabaseInitializerResolver())
                .GetService <HistoryContextFactory>();

            Assert.IsType <HistoryContextFactory>(factory);

            using (var connection = new SqlConnection())
            {
                using (var context = factory(connection, null))
                {
                    Assert.IsType <HistoryContext>(context);
                }
            }
        }
        public void The_root_resolver_uses_the_default_provider_services_resolver_and_caches_provider_instances()
        {
            var providerServices     = new Mock <DbProviderServices>().Object;
            var mockProviderResolver = new Mock <DefaultProviderServicesResolver>();

            mockProviderResolver
            .Setup(m => m.GetService(typeof(DbProviderServices), "FooClient"))
            .Returns(providerServices);

            var resolver = new RootDependencyResolver(
                mockProviderResolver.Object,
                new DatabaseInitializerResolver());

            Assert.Same(providerServices, resolver.GetService <DbProviderServices>("FooClient"));
            mockProviderResolver.Verify(m => m.GetService(typeof(DbProviderServices), "FooClient"), Times.Once());
            Assert.Same(providerServices, resolver.GetService <DbProviderServices>("FooClient"));
            mockProviderResolver.Verify(m => m.GetService(typeof(DbProviderServices), "FooClient"), Times.Once());
        }
示例#13
0
        public void The_root_resolver_resolves_from_secondary_resolvers_before_roots()
        {
            var attributeProvider1 = new Mock <AttributeProvider>().Object;
            var attributeProvider2 = new Mock <AttributeProvider>().Object;

            var mockSecondaryResolver1 = new Mock <IDbDependencyResolver>();

            mockSecondaryResolver1.Setup(m => m.GetService(typeof(AttributeProvider), null)).Returns(attributeProvider1);
            var mockSecondaryResolver2 = new Mock <IDbDependencyResolver>();

            mockSecondaryResolver2.Setup(m => m.GetService(typeof(AttributeProvider), null)).Returns(attributeProvider2);

            var rootResolver = new RootDependencyResolver();

            Assert.IsType <AttributeProvider>(rootResolver.GetService <AttributeProvider>());

            rootResolver.AddSecondaryResolver(mockSecondaryResolver1.Object);
            Assert.Same(attributeProvider1, rootResolver.GetService <AttributeProvider>());

            rootResolver.AddSecondaryResolver(mockSecondaryResolver2.Object);
            Assert.Same(attributeProvider2, rootResolver.GetService <AttributeProvider>());

            Assert.IsType <ViewAssemblyCache>(new RootDependencyResolver().GetService <IViewAssemblyCache>());
        }
        public void GetService_can_be_accessed_from_multiple_threads_concurrently()
        {
            for (var i = 0; i < 30; i++)
            {
                var bag = new ConcurrentBag<AttributeProvider>();

                var resolver = new RootDependencyResolver();

                ExecuteInParallel(() => bag.Add(resolver.GetService<AttributeProvider>()));

                Assert.Equal(20, bag.Count);
                Assert.True(bag.All(c => c.GetType() == typeof(AttributeProvider)));
            }
        }
        public void The_root_resolver_resolves_from_secondary_resolvers_before_roots()
        {
            var attributeProvider1 = new Mock<AttributeProvider>().Object;
            var attributeProvider2 = new Mock<AttributeProvider>().Object;

            var mockSecondaryResolver1 = new Mock<IDbDependencyResolver>();
            mockSecondaryResolver1.Setup(m => m.GetService(typeof(AttributeProvider), null)).Returns(attributeProvider1);
            var mockSecondaryResolver2 = new Mock<IDbDependencyResolver>();
            mockSecondaryResolver2.Setup(m => m.GetService(typeof(AttributeProvider), null)).Returns(attributeProvider2);

            var rootResolver = new RootDependencyResolver();

            Assert.IsType<AttributeProvider>(rootResolver.GetService<AttributeProvider>());

            rootResolver.AddSecondaryResolver(mockSecondaryResolver1.Object);
            Assert.Same(attributeProvider1, rootResolver.GetService<AttributeProvider>());

            rootResolver.AddSecondaryResolver(mockSecondaryResolver2.Object);
            Assert.Same(attributeProvider2, rootResolver.GetService<AttributeProvider>());

            Assert.IsType<ViewAssemblyCache>(new RootDependencyResolver().GetService<IViewAssemblyCache>());
        }
            public void RootResolver_returns_the_root_resolver()
            {
                var rootResolver = new RootDependencyResolver();

                var config = new DbConfiguration(new Mock<ResolverChain>().Object, new Mock<ResolverChain>().Object, rootResolver);

                Assert.Same(rootResolver, config.RootResolver);
            }
            public void RootResolver_returns_the_root_resolver()
            {
                var rootResolver = new RootDependencyResolver(new MigrationsConfigurationResolver(), new DefaultProviderServicesResolver());

                var config = new DbConfiguration(new Mock<ResolverChain>().Object, new Mock<ResolverChain>().Object, rootResolver);

                Assert.Same(rootResolver, config.RootResolver);
            }
示例#18
0
        /// <summary>
        ///     This method is not thread-safe and should only be used to switch in a different root resolver
        ///     before the configuration is locked and set. It is used for pushing a new configuration by
        ///     DbContextInfo while maintaining legacy settings (such as database initializers) that are
        ///     set on the root resolver.
        /// </summary>
        internal virtual void SwitchInRootResolver(RootDependencyResolver value)
        {
            Contract.Requires(value != null);

            Contract.Assert(!_isLocked);

            // The following is not thread-safe but this code is only called when pushing a configuration
            // and happens to a new DbConfiguration before it has been set and locked.
            var newChain = new ResolverChain();
            newChain.Add(value);
            _resolvers.Second.Resolvers.Skip(1).Each(newChain.Add);

            _rootResolver = value;
            _resolvers = new CompositeResolver<ResolverChain, ResolverChain>(_resolvers.First, newChain);
        }