/// <summary> /// Creates a collection of <see cref="CalculatableActivity"/> for all relevant calculations /// in the given <see cref="AssessmentSection"/>. /// </summary> /// <param name="assessmentSection">The assessment section to create the activities for.</param> /// <returns>A collection of <see cref="CalculatableActivity"/>.</returns> /// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/> is <c>null</c>.</exception> public static IEnumerable <CalculatableActivity> CreateCalculationActivities(AssessmentSection assessmentSection) { if (assessmentSection == null) { throw new ArgumentNullException(nameof(assessmentSection)); } var activities = new List <CalculatableActivity>(); activities.AddRange(PipingCalculationActivityFactory.CreateCalculationActivities( assessmentSection.Piping, assessmentSection)); activities.AddRange(GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities( assessmentSection.GrassCoverErosionInwards, assessmentSection)); activities.AddRange(MacroStabilityInwardsCalculationActivityFactory.CreateCalculationActivities( assessmentSection.MacroStabilityInwards, assessmentSection)); activities.AddRange(HeightStructuresCalculationActivityFactory.CreateCalculationActivities( assessmentSection.HeightStructures, assessmentSection)); activities.AddRange(ClosingStructuresCalculationActivityFactory.CreateCalculationActivities( assessmentSection.ClosingStructures, assessmentSection)); activities.AddRange(StabilityPointStructuresCalculationActivityFactory.CreateCalculationActivities( assessmentSection.StabilityPointStructures, assessmentSection)); return(activities); }
public void Run_CalculationInvalidInput_LogValidationStartAndEndWithError() { // Setup var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike) { HydraulicBoundaryDatabase = { FilePath = Path.Combine(testDataPath, "notexisting.sqlite") } }; var failureMechanism = new PipingFailureMechanism(); var calculation = new TestProbabilisticPipingCalculation(); CalculatableActivity activity = PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity( calculation, failureMechanism, assessmentSection); // Call void 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 CreateCalculationActivitiesForFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException() { // Call void Call() => PipingCalculationActivityFactory.CreateCalculationActivities(new PipingFailureMechanism(), null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
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 CreateSemiProbabilisticPipingCalculationActivity_AssessmentSectionNull_ThrowsArgumentNullException() { // Call void Call() => PipingCalculationActivityFactory.CreateSemiProbabilisticPipingCalculationActivity(new TestSemiProbabilisticPipingCalculation(), new GeneralPipingInput(), null); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("assessmentSection", exception.ParamName); }
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 CreateCalculationActivitiesForFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); // Call void Call() => PipingCalculationActivityFactory.CreateCalculationActivities(null, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("failureMechanism", exception.ParamName); mocks.VerifyAll(); }
public void CreateSemiProbabilisticPipingCalculationActivity_GeneralPipingInputNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); // Call void Call() => PipingCalculationActivityFactory.CreateSemiProbabilisticPipingCalculationActivity(new TestSemiProbabilisticPipingCalculation(), null, assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("generalPipingInput", exception.ParamName); mocks.VerifyAll(); }
public void CreateProbabilisticPipingCalculationActivity_CalculationNull_ThrowsArgumentNullException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); // Call void Call() => PipingCalculationActivityFactory.CreateProbabilisticPipingCalculationActivity(null, new PipingFailureMechanism(), assessmentSection); // Assert var exception = Assert.Throws <ArgumentNullException>(Call); Assert.AreEqual("calculation", exception.ParamName); mocks.VerifyAll(); }
public void CreateCalculationActivitiesForFailureMechanism_UnsupportedCalculationType_ThrowsNotSupportedException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var failureMechanism = new PipingFailureMechanism(); failureMechanism.CalculationsGroup.Children.Add(new TestPipingCalculation()); // Call void Call() => PipingCalculationActivityFactory.CreateCalculationActivities( failureMechanism, assessmentSection); // Assert Assert.Throws <NotSupportedException>(Call); mocks.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 CreateCalculationActivitiesForCalculationGroup_UnsupportedCalculationType_ThrowsNotSupportedException() { // Setup var mocks = new MockRepository(); var assessmentSection = mocks.Stub <IAssessmentSection>(); mocks.ReplayAll(); var calculationGroup = new CalculationGroup { Children = { new TestPipingCalculation() } }; // Call void Call() => PipingCalculationActivityFactory.CreateCalculationActivities( calculationGroup, new PipingFailureMechanism(), assessmentSection); // Assert Assert.Throws <NotSupportedException>(Call); mocks.VerifyAll(); }
public void Run_InvalidSectionSpecificCalculation_LogErrorAndActivityStateFailedAndOutputNotSet(bool endInFailure, string lastErrorFileContent) { // Setup var sectionSpecificCalculator = new TestPipingCalculator { LastErrorFileContent = lastErrorFileContent, EndInFailure = true }; var mocks = new MockRepository(); var observer = mocks.StrictMock <IObserver>(); var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>(); calculatorFactory.Expect(cf => cf.CreatePipingCalculator(null)) .IgnoreArguments() .Return(new TestPipingCalculator()) .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.Attach(observer); 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(8, 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]); string errorReportText = lastErrorFileContent != null ? $"Bekijk het foutrapport door op details te klikken.{Environment.NewLine}{lastErrorFileContent}" : "Er is geen foutrapport beschikbaar."; Assert.AreEqual($"De piping sterkte berekening voor vak '{calculation.Name}' is mislukt. {errorReportText}", msgs[5]); StringAssert.StartsWith("De piping sterkte berekening voor vak is uitgevoerd op de tijdelijke locatie", msgs[6]); CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[7]); }); Assert.AreEqual(ActivityState.Failed, activity.State); Assert.IsNull(calculation.Output); } mocks.VerifyAll(); // No observers notified }
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsPipingCalculationActivitiesWithParametersSet() { // Setup var assessmentSection = new AssessmentSectionStub { FailureMechanismContribution = { NormativeProbabilityType = NormativeProbabilityType.MaximumAllowableFloodingProbability } }; var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation(); var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation(); TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels(); assessmentSection.SetHydraulicBoundaryLocationCalculations(new[] { hydraulicBoundaryLocation1, hydraulicBoundaryLocation2 }); assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath; HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase); var random = new Random(39); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation1 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.First(); hydraulicBoundaryLocationCalculation1.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation2 = assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.ElementAt(1); hydraulicBoundaryLocationCalculation2.Output = new TestHydraulicBoundaryLocationCalculationOutput(random.NextDouble()); var calculation1 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>( hydraulicBoundaryLocation1); var calculation2 = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation1); var calculation3 = SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>( hydraulicBoundaryLocation2); var calculation4 = ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestProbabilisticPipingCalculation>( hydraulicBoundaryLocation2); failureMechanism.CalculationsGroup.Children.AddRange(new IPipingCalculation <PipingInput>[] { calculation1, calculation2, calculation3, calculation4 }); // Call IEnumerable <CalculatableActivity> activities = PipingCalculationActivityFactory.CreateCalculationActivities( failureMechanism, assessmentSection); // Assert Assert.AreEqual(4, activities.Count()); CalculatableActivity activity1 = activities.ElementAt(0); Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity1); AssertSemiProbabilisticPipingCalculationActivity(activity1, calculation1, hydraulicBoundaryLocationCalculation1); CalculatableActivity activity2 = activities.ElementAt(1); Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity2); AssertProbabilisticPipingCalculationActivity(activity2, calculation2, hydraulicBoundaryLocation1); CalculatableActivity activity3 = activities.ElementAt(2); Assert.IsInstanceOf <SemiProbabilisticPipingCalculationActivity>(activity3); AssertSemiProbabilisticPipingCalculationActivity(activity3, calculation3, hydraulicBoundaryLocationCalculation2); CalculatableActivity activity4 = activities.ElementAt(3); Assert.IsInstanceOf <ProbabilisticPipingCalculationActivity>(activity4); AssertProbabilisticPipingCalculationActivity(activity4, calculation4, hydraulicBoundaryLocation2); }