/// <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);
}
