public void Run_CalculationInvalidInput_LogValidationStartAndEndWithError() { // Setup var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike) { HydraulicBoundaryDatabase = { FilePath = Path.Combine(testDataPath, "notexisting.sqlite") } }; var failureMechanism = new HeightStructuresFailureMechanism(); var calculation = new StructuresCalculation <HeightStructuresInput>(); CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); // Call Action call = () => activity.Run(); // Assert TestHelper.AssertLogMessages(call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(4, msgs.Length); Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " + "Fout bij het lezen van bestand", msgs[2]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]); }); Assert.AreEqual(ActivityState.Failed, activity.State); }
public void Run_HydraulicBoundaryDatabaseWithCanUsePreprocessorFalse_CreateWaveConditionsCosineCalculatorAsExpected() { // Setup IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput(); StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity( calculation, new StabilityStoneCoverFailureMechanism(), assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull)) .WhenCalled(invocation => { HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings( HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase), (HydraRingCalculationSettings)invocation.Arguments[0]); }) .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(GetWaterLevels(calculation, assessmentSection).Count() * 2); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); } // Assert mockRepository.VerifyAll(); }
public void Run_CalculationPerformed_SetsOutput() { // Setup IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput(); StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity( calculation, new StabilityStoneCoverFailureMechanism(), assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(GetWaterLevels(calculation, assessmentSection).Count() * 2); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert Assert.IsNotNull(calculation.Output); Assert.AreEqual(3, calculation.Output.ColumnsOutput.Count()); Assert.AreEqual(3, calculation.Output.BlocksOutput.Count()); } mockRepository.VerifyAll(); }
public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivityWithParametersSet() { // Setup GrassCoverErosionOutwardsFailureMechanism failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); var assessmentSection = new AssessmentSectionStub(); HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase; hydraulicBoundaryDatabase.FilePath = validFilePath; var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1"); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }, true); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation); // Call CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationActivity>(activity); AssertGrassCoverErosionOutwardsWaveConditionsCalculationActivity( activity, calculation, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result, hydraulicBoundaryDatabase); }
public void Cancel_WhenPerformingCalculation_CurrentCalculationForWaterLevelCompletesAndSubsequentCalculationsDidNotRun() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.ProgressChanged += (sender, args) => { if (activity.State != ActivityState.Canceled) { // Call activity.Cancel(); } }; // Assert TestHelper.AssertLogMessages(() => activity.Run(), messages => { string[] msgs = messages.ToArray(); RoundedDouble firstWaterLevel = GetWaterLevels(calculation, assessmentSection).First(); Assert.AreEqual(10, msgs.Length); Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); Assert.AreEqual("Berekening voor golfoploop is gestart.", msgs[4]); Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is gestart.", msgs[5]); StringAssert.StartsWith("Golfcondities berekening is uitgevoerd op de tijdelijke locatie", msgs[6]); Assert.AreEqual($"Berekening voor waterstand '{firstWaterLevel}' is beƫindigd.", msgs[7]); Assert.AreEqual("Berekening voor golfoploop is beƫindigd.", msgs[8]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[9]); }); Assert.AreEqual(ActivityState.Canceled, activity.State); Assert.IsNull(calculation.Output); } mockRepository.VerifyAll(); }
public void CreateCalculationActivity_WithValidCalculation_ReturnsMacroStabilityInwardsCalculationActivityWithParametersSet() { // Setup var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); var assessmentSection = new AssessmentSectionStub { FailureMechanismContribution = { NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability } }; assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }); var random = new Random(39); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Single(); hydraulicBoundaryLocationCalculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); MacroStabilityInwardsCalculationScenario calculation = CreateValidCalculation(hydraulicBoundaryLocation); // Call CalculatableActivity activity = MacroStabilityInwardsCalculationActivityFactory.CreateCalculationActivity(calculation, new GeneralMacroStabilityInwardsInput(), assessmentSection); // Assert Assert.IsInstanceOf <MacroStabilityInwardsCalculationActivity>(activity); AssertMacroStabilityInwardsCalculationActivity(activity, calculation, hydraulicBoundaryLocationCalculation); }
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_ExpectedPreprocessorDirectorySetToCalculator() { // Setup var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike) { HydraulicBoundaryDatabase = { FilePath = validFilePath, Locations = { new HydraulicBoundaryLocation(1300001, string.Empty, 0, 0) }, HydraulicLocationConfigurationSettings = { CanUsePreprocessor = true, UsePreprocessor = false, PreprocessorDirectory = "InvalidPreprocessorDirectory" } } }; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>( Arg <HydraRingCalculationSettings> .Is.NotNull)) .WhenCalled(invocation => { HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings( HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase), (HydraRingCalculationSettings)invocation.Arguments[0]); }) .Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>()); mockRepository.ReplayAll(); var failureMechanism = new HeightStructuresFailureMechanism(); var calculation = new TestHeightStructuresCalculationScenario { InputParameters = { HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001) } }; CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); } // Assert mockRepository.VerifyAll(); }
public void Run_ValidCalculation_InputPropertiesCorrectlySentToService() { // Setup var mocks = new MockRepository(); var profileSpecificCalculator = new TestPipingCalculator(); var sectionSpecificCalculator = new TestPipingCalculator(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(profileSpecificCalculator) .Repeat.Once(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(sectionSpecificCalculator) .Repeat.Once(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); calculation.InputParameters.HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert PipingCalculationInput[] profileSpecificInputs = profileSpecificCalculator.ReceivedInputs.ToArray(); PipingCalculationInput[] sectionSpecificInputs = sectionSpecificCalculator.ReceivedInputs.ToArray(); Assert.AreEqual(1, profileSpecificInputs.Length); Assert.AreEqual(1, sectionSpecificInputs.Length); double sectionLength = failureMechanism.Sections.Single( s => calculation.IsSurfaceLineIntersectionWithReferenceLineInSection( Math2D.ConvertPointsToLineSegments(s.Points))).Length; AssertCalculatorInput(failureMechanism.GeneralInput, calculation.InputParameters, 0, profileSpecificInputs[0]); AssertCalculatorInput(failureMechanism.GeneralInput, calculation.InputParameters, sectionLength, sectionSpecificInputs[0]); } mocks.VerifyAll(); }
public void Finish_InvalidCalculationAndRan_DoesNotSetOutputAndNotifyObserversOfCalculation(bool endInFailure, string lastErrorFileContent) { // Setup var mockRepository = new MockRepository(); var observer = mockRepository.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); var calculator = new TestStructuresCalculator <StructuresClosureCalculationInput> { EndInFailure = endInFailure, LastErrorFileContent = lastErrorFileContent }; var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>(null)) .IgnoreArguments() .Return(calculator); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); var failureMechanism = new ClosingStructuresFailureMechanism(); var calculation = new StructuresCalculation <ClosingStructuresInput> { InputParameters = { HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1), Structure = new TestClosingStructure() } }; calculation.Attach(observer); CalculatableActivity activity = ClosingStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.Run(); } // Call activity.Finish(); // Assert Assert.IsNull(calculation.Output); mockRepository.VerifyAll(); }
public void Run_CalculationWithInvalidHydraulicBoundaryDatabaseFilePath_DoesNotPerformCalculationAndLogsError() { // Setup string invalidFilePath = Path.Combine(testDataPath, "NonExisting.sqlite"); var assessmentSection = new AssessmentSectionStub { HydraulicBoundaryDatabase = { FilePath = invalidFilePath } }; var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }); StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation); CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity( calculation, new StabilityStoneCoverFailureMechanism(), assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(4, msgs.Length); Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); Assert.AreEqual("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " + $"Fout bij het lezen van bestand '{invalidFilePath}': het bestand bestaat niet.", msgs[2]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]); }); Assert.AreEqual(ActivityState.Failed, activity.State); } mockRepository.VerifyAll(); }
public void Run_ValidCalculation_PerformValidationAndCalculationAndLogStartAndEnd() { // Setup var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(null)) .IgnoreArguments() .Return(new TestStructuresCalculator <StructuresStabilityPointCalculationInput>()); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); var failureMechanism = new StabilityPointStructuresFailureMechanism(); var calculation = new TestStabilityPointStructuresCalculationScenario { InputParameters = { HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001), InflowModelType = StabilityPointStructureInflowModelType.LowSill, LoadSchematizationType = LoadSchematizationType.Linear } }; CalculatableActivity activity = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call Action call = () => activity.Run(); // Assert TestHelper.AssertLogMessages(call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(6, msgs.Length); Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); StringAssert.StartsWith("Puntconstructies berekening is uitgevoerd op de tijdelijke locatie", msgs[4]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[5]); }); Assert.AreEqual(ActivityState.Executed, activity.State); } mockRepository.VerifyAll(); }
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorTrue_ExpectedPreprocessorDirectorySetToCalculator() { // Setup var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike) { HydraulicBoundaryDatabase = { FilePath = validFilePath, HydraulicLocationConfigurationSettings = { CanUsePreprocessor = true, UsePreprocessor = true, PreprocessorDirectory = validPreprocessorDirectory } } }; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresClosureCalculationInput>( Arg <HydraRingCalculationSettings> .Is.NotNull)) .WhenCalled(invocation => { HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings( HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase), (HydraRingCalculationSettings)invocation.Arguments[0]); }) .Return(new TestStructuresCalculator <StructuresClosureCalculationInput>()); mockRepository.ReplayAll(); var failureMechanism = new ClosingStructuresFailureMechanism(); var calculation = new TestClosingStructuresCalculationScenario(); CalculatableActivity activity = ClosingStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); } // Assert mockRepository.VerifyAll(); }
public void Finish_ValidCalculationAndRan_SetsOutputAndNotifyObserversOfCalculation() { // Setup var mockRepository = new MockRepository(); var observer = mockRepository.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(null)) .IgnoreArguments() .Return(new TestStructuresCalculator <StructuresStabilityPointCalculationInput>()); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); var failureMechanism = new StabilityPointStructuresFailureMechanism(); var calculation = new TestStabilityPointStructuresCalculationScenario { InputParameters = { HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001), InflowModelType = StabilityPointStructureInflowModelType.LowSill, LoadSchematizationType = LoadSchematizationType.Linear } }; calculation.Attach(observer); CalculatableActivity activity = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.Run(); } // Call activity.Finish(); // Assert Assert.IsNotNull(calculation.Output); mockRepository.VerifyAll(); }
public void Run_Always_SetProgressTexts() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(nrOfCalculators); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { var progressTexts = new List <string>(); activity.ProgressChanged += (sender, args) => progressTexts.Add(activity.ProgressText); // Call activity.Run(); // Assert RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray(); int totalSteps = waterLevels.Length * 2; for (var i = 0; i < totalSteps; i++) { string calculationType = i < waterLevels.Length ? "golfoploop" : "golfklap"; var text = $"Stap {i + 1} van {totalSteps} | Waterstand '{waterLevels[i % waterLevels.Length]}' [m+NAP] voor {calculationType} berekenen."; Assert.AreEqual(text, progressTexts[i]); } } mockRepository.VerifyAll(); }
public void Run_InvalidCalculationRan_PerformValidationAndCalculationActivityStateFailed(bool endInFailure, string lastErrorFileContent) { // Setup var calculator = new TestStructuresCalculator <StructuresStabilityPointCalculationInput> { EndInFailure = endInFailure, LastErrorFileContent = lastErrorFileContent }; var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(null)) .IgnoreArguments() .Return(calculator); mockRepository.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); var failureMechanism = new StabilityPointStructuresFailureMechanism(); var calculation = new TestStabilityPointStructuresCalculationScenario { InputParameters = { HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1), InflowModelType = StabilityPointStructureInflowModelType.LowSill, LoadSchematizationType = LoadSchematizationType.Linear } }; CalculatableActivity activity = StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert Assert.AreEqual(ActivityState.Failed, activity.State); } mockRepository.VerifyAll(); }
public void Run_ValidCalculation_PerformValidationAndCalculationAndLogStartAndEnd() { // Setup var mocks = new MockRepository(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(7, msgs.Length); Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]); CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]); StringAssert.StartsWith("De piping sterkte berekening voor doorsnede is uitgevoerd op de tijdelijke locatie", msgs[4]); StringAssert.StartsWith("De piping sterkte berekening voor vak is uitgevoerd op de tijdelijke locatie", msgs[5]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]); }); Assert.AreEqual(ActivityState.Executed, activity.State); } mocks.VerifyAll(); }
public void Run_WhenCanceled_OutputNull() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.ProgressChanged += (sender, args) => { if (activity.State != ActivityState.Canceled) { activity.Cancel(); } }; activity.Run(); // Call activity.Finish(); // Assert Assert.AreEqual(ActivityState.Canceled, activity.State); Assert.IsNull(calculation.Output); } mockRepository.VerifyAll(); }
public void Run_Always_SetProgressTexts() { // Setup IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput(); StabilityStoneCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); CalculatableActivity activity = StabilityStoneCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity( calculation, new StabilityStoneCoverFailureMechanism(), assessmentSection); RoundedDouble[] waterLevels = GetWaterLevels(calculation, assessmentSection).ToArray(); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(waterLevels.Length * 2); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { var progressTexts = new List <string>(); activity.ProgressChanged += (sender, args) => progressTexts.Add(activity.ProgressText); // Call activity.Run(); // Assert int totalSteps = waterLevels.Length * 2; for (var i = 0; i < totalSteps; i++) { string revetment = i < waterLevels.Length ? "blokken" : "zuilen"; var text = $"Stap {i + 1} van {totalSteps} | Waterstand '{waterLevels[i % waterLevels.Length]}' [m+NAP] voor {revetment} berekenen."; Assert.AreEqual(text, progressTexts[i]); } } mockRepository.VerifyAll(); }
public void Run_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_CreateWaveConditionsCosineCalculatorAsExpected() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true; assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = false; assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "InvalidPreprocessorDirectory"; var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull)) .WhenCalled(invocation => { HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings( HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase), (HydraRingCalculationSettings)invocation.Arguments[0]); }) .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(nrOfCalculators); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); } // Assert mockRepository.VerifyAll(); }
public void Run_CalculationFailed_OutputNull(bool endInFailure, string lastErrorFileContent) { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); var waveConditionsCosineCalculator = new TestWaveConditionsCosineCalculator { EndInFailure = endInFailure, LastErrorFileContent = lastErrorFileContent }; int nrOfCalculators = GetWaterLevels(calculation, assessmentSection).Count(); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(waveConditionsCosineCalculator) .Repeat .Times(nrOfCalculators); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert Assert.IsNull(calculation.Output); } mockRepository.VerifyAll(); }
public void Run_CalculationWithInvalidPreprocessorDirectory_DoesNotPerformCalculationAndLogsError() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true; assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = true; assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "NonExistingPreprocessorDirectory"; var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); mockRepository.ReplayAll(); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call void Call() => activity.Run(); // Assert TestHelper.AssertLogMessages(Call, messages => { string[] msgs = messages.ToArray(); Assert.AreEqual(4, msgs.Length); Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs[0]); CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]); Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[2]); CalculationServiceTestHelper.AssertValidationEndMessage(msgs[3]); }); Assert.AreEqual(ActivityState.Failed, activity.State); } mockRepository.VerifyAll(); }
public void Finish_VariousCalculationEndStates_NotifiesObserversOfCalculation(bool endInFailure) { // Setup var mockRepository = new MockRepository(); var observer = mockRepository.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>(); calculatorFactory.Stub(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator { EndInFailure = endInFailure }); mockRepository.ReplayAll(); AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); calculation.Attach(observer); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { activity.Run(); } // Call activity.Finish(); // Assert mockRepository.VerifyAll(); }
public void Run_ValidCalculation_ProgressTextSetAccordingly() { // Setup var mocks = new MockRepository(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); var progressTexts = ""; activity.ProgressChanged += (s, e) => progressTexts += activity.ProgressText + Environment.NewLine; using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert string expectedProgressTexts = "Stap 1 van 2 | Uitvoeren sterkte berekening voor doorsnede" + Environment.NewLine + "Stap 2 van 2 | Uitvoeren sterkte berekening voor vak" + Environment.NewLine; Assert.AreEqual(expectedProgressTexts, progressTexts); } mocks.VerifyAll(); }
public void GivenProbabilisticPipingCalculationActivity_WhenRunAndFinished_ThenOutputSetAndObserversNotified() { // Given var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); observer.Expect(o => o.UpdateObserver()); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .Repeat.Twice(); mocks.ReplayAll(); var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)); calculation.Attach(observer); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // When activity.Run(); activity.Finish(); // Then Assert.IsNotNull(calculation.Output); } mocks.VerifyAll(); }
public void CreateProbabilisticPipingCalculationActivity_WithValidCalculation_ReturnsActivityWithParametersSet() { // Setup var assessmentSection = new AssessmentSectionStub(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var calculation = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation); // Call CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity); AssertProbabilisticPipingCalculationActivity(activity, calculation, hydraulicBoundaryLocation); }
public void CreateSemiProbabilisticPipingCalculationActivity_WithValidCalculation_ReturnsActivityWithParametersSet() { // Setup var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); var assessmentSection = new AssessmentSectionStub { FailureMechanismContribution = { NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability } }; assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation }); var random = new Random(39); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Single(); hydraulicBoundaryLocationCalculation.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); var calculation = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>( hydraulicBoundaryLocation); var generalPipingInput = new GeneralPipingInput(); // Call CalculatableActivity activity = PipingCalculationActivityFactory.CreateSemiProbabilisticPipingCalculationActivity(calculation, generalPipingInput, assessmentSection); // Assert Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity); AssertSemiProbabilisticPipingCalculationActivity(activity, calculation, hydraulicBoundaryLocationCalculation); }
public void Run_CalculationPerformed_SetsOutput() { // Setup AssessmentSectionStub assessmentSection = CreateAssessmentSection(); ConfigureAssessmentSectionWithHydraulicBoundaryOutput(assessmentSection); GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation, failureMechanism, assessmentSection); int nrOfCalculators = GetNrOfCalculators(calculation, assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(new TestWaveConditionsCosineCalculator()) .Repeat .Times(nrOfCalculators); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert Assert.IsNotNull(calculation.Output); Assert.AreEqual(3, calculation.Output.WaveRunUpOutput.Count()); } mockRepository.VerifyAll(); }
public void Run_ErrorInCalculation_ActivityStateFailed(bool endInFailure, string lastErrorFileContent) { // Setup IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput(); WaveImpactAsphaltCoverWaveConditionsCalculation calculation = CreateValidCalculation(assessmentSection.HydraulicBoundaryDatabase.Locations.First()); CalculatableActivity activity = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity( calculation, new WaveImpactAsphaltCoverFailureMechanism(), assessmentSection); var mockRepository = new MockRepository(); var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>(); var calculator = new TestWaveConditionsCosineCalculator { EndInFailure = endInFailure, LastErrorFileContent = lastErrorFileContent }; calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(null)) .IgnoreArguments() .Return(calculator) .Repeat .Times(GetWaterLevels(calculation, assessmentSection).Count()); mockRepository.ReplayAll(); using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) { // Call activity.Run(); // Assert Assert.AreEqual(ActivityState.Failed, activity.State); } mockRepository.VerifyAll(); }
public void CreateCalculationActivity_WithValidCalculation_ReturnsWaveImpactAsphaltCoverWaveConditionsCalculationActivityWithParametersSet() { // Setup WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism(); AssessmentSectionStub assessmentSection = CreateAssessmentSection(); var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation); WaveImpactAsphaltCoverWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation); // Call CalculatableActivity activity = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <WaveImpactAsphaltCoverWaveConditionsCalculationActivity>(activity); AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activity, calculation, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result, assessmentSection.HydraulicBoundaryDatabase); }
public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionInwardsCalculationActivityWithParametersSet() { // Setup var failureMechanism = new GrassCoverErosionInwardsFailureMechanism(); var mocks = new MockRepository(); IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks, validFilePath); mocks.ReplayAll(); GrassCoverErosionInwardsCalculation calculation = CreateValidCalculation(); // Call CalculatableActivity activity = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, assessmentSection); // Assert Assert.IsInstanceOf <GrassCoverErosionInwardsCalculationActivity>(activity); AssertGrassCoverErosionInwardsCalculationActivity(activity, calculation, assessmentSection.HydraulicBoundaryDatabase); mocks.VerifyAll(); }