/// <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 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 CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsHeightStructuresCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
StructuresCalculation <HeightStructuresInput> calculation1 = CreateValidCalculation();
StructuresCalculation <HeightStructuresInput> calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = HeightStructuresCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(HeightStructuresCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertHeightStructuresCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertHeightStructuresCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
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();
}
private void Calculate(HeightStructuresCalculationScenarioContext context)
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
HeightStructuresCalculationActivityFactory.CreateCalculationActivity(context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
public void CreateCalculationActivitiesForFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Call
TestDelegate test = () => HeightStructuresCalculationActivityFactory.CreateCalculationActivities(new HeightStructuresFailureMechanism(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
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 <StructuresOvertoppingCalculationInput>
{
EndInFailure = endInFailure,
LastErrorFileContent = lastErrorFileContent
};
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath);
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new StructuresCalculation <HeightStructuresInput>
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1),
Structure = new TestHeightStructure()
}
};
calculation.Attach(observer);
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
}
// Call
activity.Finish();
// Assert
Assert.IsNull(calculation.Output);
mockRepository.VerifyAll();
}
public void Run_ValidCalculation_PerformValidationAndCalculationAndLogStartAndEnd()
{
// Setup
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
mockRepository.ReplayAll();
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath);
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
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("Hoogte kunstwerk berekening is uitgevoerd op de tijdelijke locatie", msgs[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[5]);
});
Assert.AreEqual(ActivityState.Executed, activity.State);
}
mockRepository.VerifyAll();
}
public void CreateCalculationActivity_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var calculation = new StructuresCalculation <HeightStructuresInput>();
var failureMechanism = new HeightStructuresFailureMechanism();
// Call
TestDelegate test = () => HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
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 <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
mockRepository.ReplayAll();
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath);
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
calculation.Attach(observer);
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
}
// Call
activity.Finish();
// Assert
Assert.IsNotNull(calculation.Output);
mockRepository.VerifyAll();
}
public void CreateCalculationActivitiesForFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
// Call
TestDelegate test = () => HeightStructuresCalculationActivityFactory.CreateCalculationActivities(null, assessmentSection);
// Assert
var exception = Assert.Throws <ArgumentNullException>(test);
Assert.AreEqual("failureMechanism", exception.ParamName);
mocks.VerifyAll();
}
public void Run_InvalidCalculationAndRan_PerformValidationAndCalculationAndActivityStateFailed(bool endInFailure, string lastErrorFileContent)
{
// Setup
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>
{
EndInFailure = endInFailure,
LastErrorFileContent = lastErrorFileContent
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validFilePath);
var failureMechanism = new HeightStructuresFailureMechanism();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "test", 1, 1)
}
};
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
Assert.AreEqual(ActivityState.Failed, activity.State);
}
mockRepository.VerifyAll();
}
public void CreateCalculationActivity_WithValidCalculation_ReturnsHeightStructuresCalculationActivityWithParametersSet()
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
StructuresCalculation <HeightStructuresInput> calculation = CreateValidCalculation();
// Call
CalculatableActivity activity = HeightStructuresCalculationActivityFactory.CreateCalculationActivity(calculation,
failureMechanism,
assessmentSection);
// Assert
Assert.IsInstanceOf <HeightStructuresCalculationActivity>(activity);
AssertHeightStructuresCalculationActivity(activity, calculation, assessmentSection.HydraulicBoundaryDatabase);
mocks.VerifyAll();
}
private void CalculateAllInFailureMechanism(CalculationsStateFailureMechanismContext context)
{
ActivityProgressDialogRunner.Run(
Gui.MainWindow,
HeightStructuresCalculationActivityFactory.CreateCalculationActivities(context.WrappedData, context.Parent));
}