public void ScientistDisablesExperiment()
        {
            const int expectedResult = 42;

            var mock = Substitute.For <IControlCandidate <int> >();

            mock.Control().Returns(expectedResult);
            mock.Candidate().Returns(0);

            var settings = Substitute.For <IScientistSettings>();

            settings.Enabled().Returns(Task.FromResult(false));
            using (Swap.Enabled(settings.Enabled))
            {
                var result = Scientist.Science <int>(nameof(ScientistDisablesExperiment), experiment =>
                {
                    experiment.Use(mock.Control);
                    experiment.Try(mock.Candidate);
                });

                Assert.Equal(expectedResult, result);
                mock.DidNotReceive().Candidate();
                mock.Received().Control();
                settings.Received().Enabled();
            }
        }
示例#2
0
    public void EnabledOperation()
    {
        var settings = Substitute.For <IScientistSettings>();
        var ex       = new Exception();

        settings.Enabled().Throws(ex);

        using (Swap.Enabled(settings.Enabled))
        {
            const int expectedResult = 42;

            var mock = Substitute.For <IControlCandidate <int> >();
            mock.Control().Returns(expectedResult);
            mock.Candidate().Returns(0);

            var result = Scientist.Science <int>(nameof(EnabledOperation), experiment =>
            {
                experiment.Thrown(mock.Thrown);
                experiment.Use(mock.Control);
                experiment.Try(mock.Candidate);
            });

            Assert.Equal(expectedResult, result);
            mock.Received().Thrown(Operation.Enabled, ex);
        }
    }
        public void NoCandidateMeansNoDisable()
        {
            var settings = Substitute.For <IScientistSettings>();

            settings.Enabled().Returns(Task.FromResult(false));

            using (Swap.Enabled(settings.Enabled))
            {
                Scientist.Science <int>("noCandidateNoDisable", experiment =>
                {
                    experiment.Use(() => 42);
                });

                settings.DidNotReceive().Enabled();
            }
        }
        public void ScientistDisablesAllExperiments()
        {
            const int expectedResult = 42;

            var mock = Substitute.For <IControlCandidate <int> >();

            mock.Control().Returns(expectedResult);
            mock.Candidate().Returns(0);

            var settings = Substitute.For <IScientistSettings>();

            settings.Enabled().Returns(Task.FromResult(false));

            var instanceMock = Substitute.For <IControlCandidate <int> >();

            instanceMock.Control().Returns(expectedResult);
            instanceMock.Candidate().Returns(0);

            using (Swap.Enabled(settings.Enabled))
            {
                var result = Scientist.Science <int>(nameof(ScientistDisablesExperiment), experiment =>
                {
                    experiment.Use(mock.Control);
                    experiment.Try(mock.Candidate);
                });

                mock.DidNotReceive().Candidate();
                mock.Received().Control();
                settings.Received().Enabled();

                var scientist = new Scientist(Substitute.For <IResultPublisher>());
                scientist.Experiment <int>(nameof(ScientistDisablesAllExperiments), experiment =>
                {
                    experiment.Use(instanceMock.Control);
                    experiment.Try(instanceMock.Candidate);
                });

                instanceMock.DidNotReceive().Candidate();
                instanceMock.Received().Control();
                settings.Received().Enabled();
            }
        }