public void RegistrationCensor_RegisterAll_DependancyOrder2()
        {
            if (!this.ExecuteOrderTests)
            {
                Assert.Inconclusive("!this.ExecuteOrderTests");
            }

            // Arrange
            RegistratorTest1.ValidContext = null;
            RegistratorTest2.ValidContext = null;
            RegistratorTest1.Dependancy   = nameof(RegistratorTest2);
            RegistratorTest2.Dependancy   = null;

            string expectedCallOrder = "RegistratorTest2RegistratorTest1";
            string actualCallOrder   = "";

            var mockContainer = new Mock <IContainer>(MockBehavior.Strict);

            mockContainer.Setup(m => m.Register(It.IsAny <string>()))
            .Callback <string>((n) => { actualCallOrder += n; });

            // Act
            RegistrationCensor <IContainer> .RegisterAll(mockContainer.Object);

            // Assert
            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(2));
            Assert.AreEqual(expectedCallOrder, actualCallOrder);
        }
        public void RegistrationCensor_RegisterAll_Dependancy_Missing()
        {
            if (!this.ExecuteOrderTests)
            {
                Assert.Inconclusive("!this.ExecuteOrderTests");
            }

            // Arrange
            RegistratorTest1.ValidContext = null;
            RegistratorTest2.ValidContext = null;
            RegistratorTest1.Dependancy   = "MissingDependancy";
            RegistratorTest2.Dependancy   = nameof(RegistratorTest1);

            var mockContainer = new Mock <IContainer>(MockBehavior.Strict);

            mockContainer.Setup(m => m.Register(It.IsAny <string>()));

            // Act
            try
            {
                RegistrationCensor <IContainer> .RegisterAll(mockContainer.Object);

                Assert.Fail("Shouldn't reach this point.");
            }
            catch (MissingDependencyException)
            { }
            catch
            {
                Assert.Fail("Shouldn't reach this point.");
            }

            // Assert
            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(0));
        }
        public void RegistrationCensor_RegisterAllAsync_Slow()
        {
            if (!this.ExecuteSlowTests)
            {
                Assert.Inconclusive("!this.ExecuteSlowTests");
            }

            // Arrange
            RegistratorTest1.ValidContext = null;
            RegistratorTest2.ValidContext = null;
            RegistratorTest1.Dependancy   = null;
            RegistratorTest2.Dependancy   = null;

            var mockContainer = new Mock <IContainer>(MockBehavior.Strict);

            mockContainer.Setup(m => m.Register(It.IsAny <string>())).Callback(() => Thread.Sleep(250));

            // Act
            var registrationTask = RegistrationCensor <IContainer> .RegisterAllAsync(mockContainer.Object, "");

            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(0));
            Thread.Sleep(250);
            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(1));
            var executed = registrationTask.Wait(500);

            // Assert
            Assert.IsTrue(executed);
            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(2));
        }
Beispiel #4
0
        static void Main(string[] args)
        {
            var container = new UnityContainer();

            RegistrationCensor <IUnityContainer> .RegisterAll(container, "PIMP.DISample.*");

            var potatoExtractor = container.Resolve <IPotatoExtractor>();
            int count           = potatoExtractor.CountPotatoYield();

            Console.WriteLine($"Just extracted {count} potatos!");
            Console.ReadLine();
        }
        public void RegistrationCensor_RegisterAll_OneContextFilterWrong()
        {
            // Arrange
            RegistratorTest1.ValidContext = null;
            RegistratorTest2.ValidContext = "Bar";
            RegistratorTest1.Dependancy   = null;
            RegistratorTest2.Dependancy   = null;

            var mockContainer = new Mock <IContainer>(MockBehavior.Strict);

            mockContainer.Setup(m => m.Register(It.IsAny <string>()));

            // Act
            RegistrationCensor <IContainer> .RegisterAll(mockContainer.Object, "");

            // Assert
            mockContainer.Verify(m => m.Register(It.IsAny <string>()), Times.Exactly(1));
        }