public void ShouldCreateSimulation()
        {
            // Arrange
            var simulationStore = A.Fake <IStoreSimulations <MaternityBenefitsCase> >();
            var personStore     = A.Fake <IStorePersons <MaternityBenefitsPerson> >();
            var resultStore     = A.Fake <IStoreSimulationResults <MaternityBenefitsCase> >();
            var runner          = A.Fake <IRunSimulations <MaternityBenefitsCase, MaternityBenefitsPerson> >();

            var testId     = Guid.NewGuid();
            var simulation = new Simulation <MaternityBenefitsCase>()
            {
                Id = testId
            };

            // Act
            var sut = new SimulationRequestHandler(simulationStore, resultStore, runner, personStore);

            sut.CreateSimulation(simulation);

            // Assert
            A.CallTo(() => simulationStore.Save(A <Simulation <MaternityBenefitsCase> > ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => personStore.GetAllPersons()).MustHaveHappenedOnceExactly();
            A.CallTo(() => runner.Run(A <Simulation <MaternityBenefitsCase> > ._, A <IEnumerable <MaternityBenefitsPerson> > ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => resultStore.Save(testId, A <SimulationResult> ._)).MustHaveHappenedOnceExactly();
        }
        public void ShouldGetSimulation()
        {
            // Arrange
            var simulationStore = A.Fake <IStoreSimulations <MaternityBenefitsCase> >();
            var personStore     = A.Fake <IStorePersons <MaternityBenefitsPerson> >();
            var resultStore     = A.Fake <IStoreSimulationResults <MaternityBenefitsCase> >();
            var runner          = A.Fake <IRunSimulations <MaternityBenefitsCase, MaternityBenefitsPerson> >();

            var testId     = Guid.NewGuid();
            var testName   = "My Fake Simulation";
            var simulation = new Simulation <MaternityBenefitsCase>()
            {
                Id   = testId,
                Name = testName
            };

            A.CallTo(() => simulationStore.Get(testId)).Returns(simulation);

            // Act
            var sut    = new SimulationRequestHandler(simulationStore, resultStore, runner, personStore);
            var result = sut.GetSimulation(testId);

            // Assert
            A.CallTo(() => simulationStore.Get(testId)).MustHaveHappenedOnceExactly();
            Assert.Equal(testId, result.Id);
            Assert.Equal(testName, result.Name);
        }
Exemple #3
0
        public void ShouldWorkNormally()
        {
            // Arrange
            var simulationStore   = A.Fake <IStoreSimulations <ISimulationCase> >();
            var personStore       = A.Fake <IStorePersons <IPerson> >();
            var runner            = A.Fake <IRunSimulations <ISimulationCase, IPerson> >();
            var simulationBuilder = A.Fake <IBuildSimulations <ISimulationCase, ISimulationCaseRequest> >();

            var testId     = Guid.NewGuid();
            var simulation = new Simulation <ISimulationCase>()
            {
                Id = testId
            };

            A.CallTo(() => simulationBuilder.Build(A <SimulationRequest <ISimulationCaseRequest> > ._)).Returns(simulation);


            // Act
            var sut = new SimulationRequestHandler <
                ISimulationCase,
                ISimulationCaseRequest,
                IPerson>
                          (simulationBuilder, simulationStore, personStore, runner);

            var request = new SimulationRequest <ISimulationCaseRequest>();

            var result = sut.Handle(request);


            // Assert
            A.CallTo(() => simulationBuilder.Build(A <SimulationRequest <ISimulationCaseRequest> > ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => simulationStore.SaveSimulation(A <Simulation <ISimulationCase> > ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => personStore.GetAllPersons()).MustHaveHappenedOnceExactly();
            A.CallTo(() => runner.Run(A <Simulation <ISimulationCase> > ._, A <IEnumerable <IPerson> > ._)).MustHaveHappenedOnceExactly();
            A.CallTo(() => simulationStore.StoreResults(testId, A <SimulationResult> ._)).MustHaveHappenedOnceExactly();

            Assert.Equal(result, testId);
        }