Exemple #1
0
        public void ModuleManagerRunCalled()
        {
            // Have to use a non-mocked container because of IsRegistered<> extension method, Registrations property,and ContainerRegistration
            var mockedModuleInitializer = new Mock <IModuleInitializer>();
            var mockedModuleManager     = new Mock <IModuleManager>();
            var regionAdapterMappings   = new RegionAdapterMappings();
            var container             = ContainerHelper.CreateContainerExtension();
            var regionBehaviorFactory = new RegionBehaviorFactory(container);

            container.RegisterInstance <IContainerExtension>(container);
            container.RegisterInstance <IModuleCatalog>(new ModuleCatalog());
            container.RegisterInstance <IModuleInitializer>(mockedModuleInitializer.Object);
            container.RegisterInstance <IModuleManager>(mockedModuleManager.Object);
            container.RegisterInstance <RegionAdapterMappings>(regionAdapterMappings);

            container.RegisterSingleton(typeof(RegionAdapterMappings), typeof(RegionAdapterMappings));
            container.RegisterSingleton(typeof(IRegionManager), typeof(RegionManager));
            container.RegisterSingleton(typeof(IEventAggregator), typeof(EventAggregator));
            container.RegisterSingleton(typeof(IRegionViewRegistry), typeof(RegionViewRegistry));
            container.RegisterSingleton(typeof(IRegionBehaviorFactory), typeof(RegionBehaviorFactory));
            container.RegisterSingleton(typeof(IRegionNavigationJournalEntry), typeof(RegionNavigationJournalEntry));
            container.RegisterSingleton(typeof(IRegionNavigationJournal), typeof(RegionNavigationJournal));
            container.RegisterSingleton(typeof(IRegionNavigationService), typeof(RegionNavigationService));
            container.RegisterSingleton(typeof(IRegionNavigationContentLoader), typeof(RegionNavigationContentLoader));

            container.RegisterInstance <SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory));
            container.RegisterInstance <ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory));
            container.RegisterInstance <ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory));

            var bootstrapper = new MockedContainerBootstrapper(container.GetBaseContainer());

            bootstrapper.Run(false);

            mockedModuleManager.Verify(mm => mm.Run(), Times.Once());
        }
        private static void SetupMockedContainerForVerificationTests(Mock <IContainer> mockedContainer)
        {
            var mockedModuleInitializer = new Mock <IModuleInitializer>();
            var mockedModuleManager     = new Mock <IModuleManager>();
            var regionAdapterMappings   = new RegionAdapterMappings();

            var containerExtension    = new DryIocContainerExtension(mockedContainer.Object);
            var regionBehaviorFactory = new RegionBehaviorFactory(containerExtension);

            mockedContainer.Setup(c => c.Register(It.IsAny <Factory>(), It.IsAny <Type>(), It.IsAny <string>(), It.IsAny <IfAlreadyRegistered?>(), It.IsAny <bool>()));

            // NOTE: The actual method called by Prism's DryIocContainerExtension is off over the IResolver not IContainer
            mockedContainer.As <IResolver>().Setup(r => r.Resolve(typeof(IModuleCatalog), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                new ModuleCatalog());

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(IModuleInitializer), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                mockedModuleInitializer.Object);

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(IModuleManager), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                mockedModuleManager.Object);

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(RegionAdapterMappings), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                regionAdapterMappings);

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(SelectorRegionAdapter), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                new SelectorRegionAdapter(regionBehaviorFactory));

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(ItemsControlRegionAdapter), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                new ItemsControlRegionAdapter(regionBehaviorFactory));

            mockedContainer.As <IResolver>().Setup(c => c.Resolve(typeof(ContentControlRegionAdapter), It.IsAny <object>(), IfUnresolved.Throw, It.IsAny <Type>(), It.IsAny <Request>(), It.IsAny <object[]>())).Returns(
                new ContentControlRegionAdapter(regionBehaviorFactory));
        }
        private static void SetupMockedContainerForVerificationTests(Mock <IContainer> mockedContainer)
        {
            var mockedModuleInitializer = new Mock <IModuleInitializer>();
            var mockedModuleManager     = new Mock <IModuleManager>();
            var regionAdapterMappings   = new RegionAdapterMappings();

            var containerExtension    = new DryIocContainerExtension(mockedContainer.Object);
            var regionBehaviorFactory = new RegionBehaviorFactory(containerExtension);

            mockedContainer.Setup(c => c.Register(It.IsAny <Factory>(), It.IsAny <Type>(), It.IsAny <string>(), It.IsAny <IfAlreadyRegistered?>(), It.IsAny <bool>()));

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleCatalog), IfUnresolved.Throw)).Returns(
                new ModuleCatalog());

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleInitializer), IfUnresolved.Throw)).Returns(
                mockedModuleInitializer.Object);

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleManager), IfUnresolved.Throw)).Returns(
                mockedModuleManager.Object);

            mockedContainer.Setup(c => c.Resolve(typeof(RegionAdapterMappings), IfUnresolved.Throw)).Returns(
                regionAdapterMappings);

            mockedContainer.Setup(c => c.Resolve(typeof(SelectorRegionAdapter), IfUnresolved.Throw)).Returns(
                new SelectorRegionAdapter(regionBehaviorFactory));

            mockedContainer.Setup(c => c.Resolve(typeof(ItemsControlRegionAdapter), IfUnresolved.Throw)).Returns(
                new ItemsControlRegionAdapter(regionBehaviorFactory));

            mockedContainer.Setup(c => c.Resolve(typeof(ContentControlRegionAdapter), IfUnresolved.Throw)).Returns(
                new ContentControlRegionAdapter(regionBehaviorFactory));
        }
Exemple #4
0
        private static void SetupMockedContainerForVerificationTests(Mock <IUnityContainer> mockedContainer)
        {
            var mockedModuleInitializer = new Mock <IModuleInitializer>();
            var mockedModuleManager     = new Mock <IModuleManager>();
            var regionAdapterMappings   = new RegionAdapterMappings();
            var serviceLocatorAdapter   = new UnityServiceLocatorAdapter(mockedContainer.Object);
            var regionBehaviorFactory   = new RegionBehaviorFactory(serviceLocatorAdapter);

            mockedContainer.Setup(c => c.Resolve(typeof(IServiceLocator), (string)null)).Returns(serviceLocatorAdapter);

            mockedContainer.Setup(c => c.RegisterInstance(It.IsAny <Type>(), It.IsAny <string>(), It.IsAny <object>(), It.IsAny <IInstanceLifetimeManager>()));

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleCatalog), (string)null)).Returns(
                new ModuleCatalog());

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleInitializer), (string)null)).Returns(
                mockedModuleInitializer.Object);

            mockedContainer.Setup(c => c.Resolve(typeof(IModuleManager), (string)null)).Returns(
                mockedModuleManager.Object);


            mockedContainer.Setup(c => c.Resolve(typeof(RegionAdapterMappings), (string)null)).Returns(
                regionAdapterMappings);

//            mockedContainer.Setup(c => c.Resolve(typeof(SelectorRegionAdapter), (string)null)).Returns(
//                new SelectorRegionAdapter(regionBehaviorFactory));

            mockedContainer.Setup(c => c.Resolve(typeof(ItemsControlRegionAdapter), (string)null)).Returns(
                new ItemsControlRegionAdapter(regionBehaviorFactory));

            mockedContainer.Setup(c => c.Resolve(typeof(ContentControlRegionAdapter), (string)null)).Returns(
                new ContentControlRegionAdapter(regionBehaviorFactory));
        }
Exemple #5
0
        protected override void RegisterRequiredTypes(IContainerRegistry containerRegistry)
        {
            RegisterRequiredTypesCalled = true;

            base.RegisterRequiredTypes(containerRegistry);

            var logger = new TextLogger();

            MockContainer.Setup(x => x.Resolve(typeof(ILoggerFacade))).Returns(logger);

            var moduleInitializer = new ModuleInitializer(MockContainer.Object, logger);

            MockContainer.Setup(x => x.Resolve(typeof(IModuleInitializer))).Returns(moduleInitializer);
            MockContainer.Setup(x => x.Resolve(typeof(IModuleManager))).Returns(new ModuleManager(moduleInitializer, DefaultModuleCatalog, logger));
            MockContainer.Setup(x => x.Resolve(typeof(IRegionBehaviorFactory))).Returns(new RegionBehaviorFactory(MockContainer.Object));

            var regionBehaviorFactory = new RegionBehaviorFactory(MockContainer.Object);

            MockContainer.Setup(x => x.Resolve(typeof(IRegionBehaviorFactory))).Returns(regionBehaviorFactory);

            MockContainer.Setup(x => x.Resolve(typeof(RegionAdapterMappings))).Returns(new RegionAdapterMappings());
            MockContainer.Setup(x => x.Resolve(typeof(SelectorRegionAdapter))).Returns(new SelectorRegionAdapter(regionBehaviorFactory));
            MockContainer.Setup(x => x.Resolve(typeof(ItemsControlRegionAdapter))).Returns(new ItemsControlRegionAdapter(regionBehaviorFactory));
            MockContainer.Setup(x => x.Resolve(typeof(ContentControlRegionAdapter))).Returns(new ContentControlRegionAdapter(regionBehaviorFactory));
        }
        public void ModuleManagerRunCalled()
        {
            // Have to use a non-mocked container because of IsRegistered<> extension method, Registrations property,and ContainerRegistration
            var container = new WindsorContainer();

            var mockedModuleInitializer = new Mock <IModuleInitializer>();
            var mockedModuleManager     = new Mock <IModuleManager>();
            var regionAdapterMappings   = new RegionAdapterMappings();
            var serviceLocatorAdapter   = new CastleWindsorServiceLocatorAdapter(container);
            var regionBehaviorFactory   = new RegionBehaviorFactory(serviceLocatorAdapter);

            container.Register(Component.For(typeof(IServiceLocator)).Instance(serviceLocatorAdapter).LifeStyle.Transient);
            container.Register(Component.For(typeof(IModuleCatalog)).Instance(mockedModuleInitializer.Object).LifeStyle.Transient);
            container.Register(Component.For(typeof(IModuleInitializer)).Instance(new ModuleCatalog()).LifeStyle.Transient);
            container.Register(Component.For(typeof(IModuleManager)).Instance(mockedModuleManager.Object).LifeStyle.Transient);
            container.Register(Component.For(typeof(RegionAdapterMappings)).Instance(regionAdapterMappings).LifeStyle.Transient);


            //container.RegisterInstance<IServiceLocator>(serviceLocatorAdapter);
            //container.RegisterInstance<IModuleCatalog>(new ModuleCatalog());
            //container.RegisterInstance<IModuleInitializer>(mockedModuleInitializer.Object);
            //container.RegisterInstance<IModuleManager>(mockedModuleManager.Object);
            //container.RegisterInstance<RegionAdapterMappings>(regionAdapterMappings);

            container.RegisterType <RegionAdapterMappings, RegionAdapterMappings>(true);
            container.RegisterType <IRegionManager, RegionManager>(true);
            container.RegisterType <IRegionViewRegistry, EventAggregator>(true);
            container.RegisterType <IRegionViewRegistry, RegionViewRegistry>(true);
            container.RegisterType <IRegionBehaviorFactory, RegionBehaviorFactory>(true);
            container.RegisterType <IRegionNavigationJournalEntry, RegionNavigationJournalEntry>(true);
            container.RegisterType <IRegionNavigationJournal, RegionNavigationJournal>(true);
            container.RegisterType <IRegionNavigationService, RegionNavigationService>(true);
            container.RegisterType <IRegionNavigationContentLoader, CastleWindsorRegionNavigationContentLoader>(true);

            //container.RegisterSingleton(typeof(RegionAdapterMappings), typeof(RegionAdapterMappings));
            //container.RegisterSingleton(typeof(IRegionManager), typeof(RegionManager));
            //container.RegisterSingleton(typeof(IEventAggregator), typeof(EventAggregator));
            //container.RegisterSingleton(typeof(IRegionViewRegistry), typeof(RegionViewRegistry));
            //container.RegisterSingleton(typeof(IRegionBehaviorFactory), typeof(RegionBehaviorFactory));
            //container.RegisterSingleton(typeof(IRegionNavigationJournalEntry), typeof(RegionNavigationJournalEntry));
            //container.RegisterSingleton(typeof(IRegionNavigationJournal), typeof(RegionNavigationJournal));
            //container.RegisterSingleton(typeof(IRegionNavigationService), typeof(RegionNavigationService));
            //container.RegisterSingleton(typeof(IRegionNavigationContentLoader), typeof(global::Prism.Regions.CastleWindsorRegionNavigationContentLoader));

            container.RegisterInstance <SelectorRegionAdapter, SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory));
            container.RegisterInstance <ItemsControlRegionAdapter, ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory));
            container.RegisterInstance <ContentControlRegionAdapter, ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory));

            //container.RegisterInstance<SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory));
            //container.RegisterInstance<ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory));
            //container.RegisterInstance<ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory));

            var bootstrapper = new MockedContainerBootstrapper(container);

            bootstrapper.Run(false);

            mockedModuleManager.Verify(mm => mm.Run(), Times.Once());
        }
Exemple #7
0
        public void AddTypeThatDoesNotInheritFromIRegionBehaviorThrows()
        {
            var ex = Assert.Throws <ArgumentException>(() =>
            {
                RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

                factory.AddIfMissing("key1", typeof(object));
            });
        }
Exemple #8
0
        private static void SetupRegionBehaviorAdapters(CompositionContainer container)
        {
            var regionBehaviorFactory = new RegionBehaviorFactory(new MefServiceLocatorAdapter(container));

            container.ComposeExportedValue <SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue <ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue <ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue <RegionAdapterMappings>(new RegionAdapterMappings());
        }
        public void WillNotAddTypesWithDuplicateKeys()
        {
            RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

            factory.AddIfMissing("key1", typeof(MockRegionBehavior));
            factory.AddIfMissing("key1", typeof(MockRegionBehavior));

            Assert.AreEqual(1, factory.Count());
        }
Exemple #10
0
        public void WillNotAddTypesWithDuplicateKeys()
        {
            var factory = new RegionBehaviorFactory(null);

            factory.AddIfMissing <MockRegionBehavior>("key1");
            factory.AddIfMissing <MockRegionBehavior>("key1");

            Assert.Single(factory);
        }
Exemple #11
0
        public void CreateWithUnknownKeyThrows()
        {
            var ex = Assert.Throws <ArgumentException>(() =>
            {
                RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

                factory.CreateFromKey("Key1");
            });
        }
        private static void CreateAndConfigureServiceLocatorWithDefaultRegionBehaviors()
        {
            var containerExtension    = new Mock <IContainerExtension>();
            var regionBehaviorFactory = new RegionBehaviorFactory(containerExtension.Object);

            containerExtension.Setup(sl => sl.Resolve(typeof(IRegionBehaviorFactory))).Returns(new RegionBehaviorFactory(containerExtension.Object));

            ContainerLocator.ResetContainer();
            ContainerLocator.SetContainerExtension(() => containerExtension.Object);
        }
        public void CanRegisterType()
        {
            RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

            factory.AddIfMissing("key1", typeof(MockRegionBehavior));
            factory.AddIfMissing("key2", typeof(MockRegionBehavior));

            Assert.AreEqual(2, factory.Count());
            Assert.IsTrue(factory.ContainsKey("key1"));
        }
Exemple #14
0
        public void CanRegisterType()
        {
            var factory = new RegionBehaviorFactory(null);

            factory.AddIfMissing <MockRegionBehavior>("key1");
            factory.AddIfMissing <MockRegionBehavior>("key2");

            Assert.Equal(2, factory.Count());
            Assert.True(factory.ContainsKey("key1"));
        }
        private static void CreateAndConfigureServiceLocatorWithRegionAdapters()
        {
            Mock <ServiceLocatorImplBase> serviceLocator = new Mock <ServiceLocatorImplBase>();
            var regionBehaviorFactory = new RegionBehaviorFactory(serviceLocator.Object);

            serviceLocator.Setup(sl => sl.GetInstance <RegionAdapterMappings>()).Returns(new RegionAdapterMappings());
            serviceLocator.Setup(sl => sl.GetInstance <SelectorRegionAdapter>()).Returns(new SelectorRegionAdapter(regionBehaviorFactory));
            serviceLocator.Setup(sl => sl.GetInstance <ItemsControlRegionAdapter>()).Returns(new ItemsControlRegionAdapter(regionBehaviorFactory));
            serviceLocator.Setup(sl => sl.GetInstance <ContentControlRegionAdapter>()).Returns(new ContentControlRegionAdapter(regionBehaviorFactory));

            ServiceLocator.SetLocatorProvider(() => serviceLocator.Object);
        }
        private MockServiceLocator GetServiceLocator(string[] defaultRegions)
        {
            MockServiceLocator locator = new MockServiceLocator();
            var regionViewRegistry     = new RegionViewRegistry(locator);
            var behavior = new AutoPopulateRegionBehavior(regionViewRegistry);
            var regionBehaviorFactory = new RegionBehaviorFactory(locator);

            regionBehaviorFactory.AddIfMissing(AutoPopulateRegionBehavior.BehaviorKey, typeof(AutoPopulateRegionBehavior));
            var regionManager = new RegionManager(regionBehaviorFactory);

            locator.GetInstance = (type) =>
            {
                if (type == typeof(IRegionManager))
                {
                    return(regionManager);
                }
                if (type == typeof(IRegionViewRegistry))
                {
                    return(regionViewRegistry);
                }
                if (type == typeof(AutoPopulateRegionBehavior))
                {
                    return(behavior);
                }
                if (type == typeof(IRegionBehaviorFactory))
                {
                    return(regionBehaviorFactory);
                }
                if (type == typeof(IServiceLocator))
                {
                    return(locator);
                }
                if (type == typeof(MockView))
                {
                    return(new MockView());
                }
                if (type == typeof(object))
                {
                    return(new object());
                }
                return(null);
            };

            foreach (var region in defaultRegions)
            {
                regionManager.Regions.Add(new MockRegion {
                    Name = region
                });
            }

            return(locator);
        }
        private static void CreateAndConfigureServiceLocatorWithRegionAdapters()
        {
            var container             = new Mock <IContainerExtension>();
            var regionBehaviorFactory = new RegionBehaviorFactory(container.Object);

            container.Setup(sl => sl.Resolve(typeof(RegionAdapterMappings))).Returns(new RegionAdapterMappings());
            container.Setup(sl => sl.Resolve(typeof(SelectorRegionAdapter))).Returns(new SelectorRegionAdapter(regionBehaviorFactory));
            container.Setup(sl => sl.Resolve(typeof(ItemsControlRegionAdapter))).Returns(new ItemsControlRegionAdapter(regionBehaviorFactory));
            container.Setup(sl => sl.Resolve(typeof(ContentControlRegionAdapter))).Returns(new ContentControlRegionAdapter(regionBehaviorFactory));

            ContainerLocator.ResetContainer();
            ContainerLocator.SetContainerExtension(() => container.Object);
        }
Exemple #18
0
        public void CanCreateRegisteredType()
        {
            var expectedBehavior = new MockRegionBehavior();
            var containerMock    = new Mock <IContainerExtension>();

            containerMock.Setup(c => c.Resolve(typeof(MockRegionBehavior))).Returns(expectedBehavior);
            RegionBehaviorFactory factory = new RegionBehaviorFactory(containerMock.Object);

            factory.AddIfMissing("key1", typeof(MockRegionBehavior));
            var behavior = factory.CreateFromKey("key1");

            Assert.Same(expectedBehavior, behavior);
        }
        public void CanCreateRegisteredType()
        {
            var expectedBehavior = new MockRegionBehavior();

            RegionBehaviorFactory factory = new RegionBehaviorFactory(new MockServiceLocator()
            {
                GetInstance = (t) => expectedBehavior
            });

            factory.AddIfMissing("key1", typeof(MockRegionBehavior));
            var behavior = factory.CreateFromKey("key1");

            Assert.AreSame(expectedBehavior, behavior);
        }
        private static void SetupRegionBehaviorAdapters(CompositionContainer container)
        {
            var regionBehaviorFactory = new RegionBehaviorFactory(new MefServiceLocatorAdapter(container));
#if SILVERLIGHT
            container.ComposeExportedValue<TabControlRegionAdapter>(new TabControlRegionAdapter(regionBehaviorFactory));
#endif

            container.ComposeExportedValue<SelectorRegionAdapter>(new SelectorRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue<ItemsControlRegionAdapter>(new ItemsControlRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue<ContentControlRegionAdapter>(new ContentControlRegionAdapter(regionBehaviorFactory));
            container.ComposeExportedValue<RegionAdapterMappings>(new RegionAdapterMappings());
        }
 public StackPanelRegionAdapter(RegionBehaviorFactory behaviorFactory)
     : base(behaviorFactory)
 {
 }
        public void CreateWithUnknownKeyThrows()
        {
            RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

            factory.CreateFromKey("Key1");
        }
        public void AddTypeThatDoesNotInheritFromIRegionBehaviorThrows()
        {
            RegionBehaviorFactory factory = new RegionBehaviorFactory(null);

            factory.AddIfMissing("key1", typeof(object));
        }
Exemple #24
0
 protected override void AttachDefaultBehaviors(IRegion region, ContentControl regionTarget)
 {
     base.AttachDefaultBehaviors(region, regionTarget);
     RegionBehaviorFactory.AddIfMissing("DefaultBehavior", typeof(AutoPopulateRegionBehavior));
 }
 public StackPanelRegionAdapter(RegionBehaviorFactory f) :
     base(f)
 {
 }