public static void Run()
        {
            var store = new EmbeddableDocumentStore();
            store.Initialize();
            store.Conventions.AllowQueriesOnId = true;

            var context = new RavenDbContext(store);

            var serviceCollection = new ServiceCollection();
            serviceCollection.Singleton<IDocumentStore>(provider => store);
            serviceCollection.Scoped<IUnitOfWork, RavenDbContext>();
            serviceCollection.Scoped(typeof(IRepository<>), typeof(RavenDbRepository<>));
            serviceCollection.Update();
        }
        public static void MyClassInitialize(TestContext testContext)
        {
            var serviceCollection = new ServiceCollection();
            serviceCollection.Transient<IDocumentService>(p => new RepositoryService());

            // prepare substitude of IUnitOfWork;
            var unitOfWork = Substitute.For<IUnitOfWork>();
            unitOfWork.When(s => s.SaveChanges())
                .Do(c => saveAllChanges = true);

            serviceCollection.Scoped<IUnitOfWork>(p => unitOfWork);
            serviceCollection.Scoped(typeof(IRepository<>), typeof(SubRepository<>));
            serviceCollection.Update();
        }
        public void GetGenericServiceTest()
        {
            var serviceCollection = new ServiceCollection();
            serviceCollection.Scoped(typeof(IGenericFooService<>), typeof(GenericFooService<>));
            serviceCollection.Update();
            var actual = ServiceProvider.Current.GetService<IGenericFooService<int>>();

            Assert.IsNotNull(actual);
        }
        public void GetGenericInstanceTest()
        {
            var serviceCollection = new ServiceCollection();
            var expected = new GenericFooService<int>();
            expected.Value = 4;
            serviceCollection.Scoped(typeof(IGenericFooService<>), provider => new GenericFooService<int>());

            serviceCollection.Update();

            var actual = ServiceProvider.Current.GetService<IGenericFooService<int>>();

            Assert.AreEqual(expected.Value, actual.Value);
        }
        public static void Run()
        {
            var serviceCollection = new ServiceCollection();

            var dictionary = new Dictionary<int, object>();

            dictionary.Add(typeof(MongoSettings).GetHashCode(), new MongoSettings {
                DatabaseName = "MetadataStore",
                Host = "localhost",
                Port = 27017,
                Timeout = 2
            });

            // Register ISettingsProvider as singleton.;
            var provider = new DictionarySettingProvider(dictionary);

            serviceCollection.Singleton<ISettingsProvider>(p => provider);

            serviceCollection.Scoped<IUnitOfWork, MongoContext>();
            serviceCollection.Scoped(typeof(IRepository<>), typeof(MongoRepository<>));

            // Update registration.
            serviceCollection.Update();
        }
        public void GetServiceTest()
        {
            var serviceCollection = new ServiceCollection();
            serviceCollection.Scoped<IFooService, FooService>();
            serviceCollection.Update();
            var actual = ServiceProvider.Current.GetService<IFooService>();

            Assert.IsNotNull(actual);
        }
        public void GetInstanceTest()
        {
            var serviceCollection = new ServiceCollection();
            var expected = new FooService();
            expected.Value = 4;
            serviceCollection.Scoped<IFooService>(provider => expected);
            serviceCollection.Update();
            var actual = ServiceProvider.Current.GetService<IFooService>();

            Assert.AreEqual(expected.Value, actual.Value);
        }