public void GivenFormWithAssemblyResultTotalView_WhenCalculationNotifiesObservers_ThenRefreshButtonEnabledAndWarningSet()
{
// Given
AssessmentSection assessmentSection = CreateAssessmentSection();
var calculation = new TestHeightStructuresCalculationScenario();
assessmentSection.HeightStructures.CalculationsGroup.Children.Add(calculation);
using (AssemblyResultTotalView view = ShowAssemblyResultTotalView(assessmentSection))
{
// Precondition
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
Button button = buttonTester.Properties;
Assert.IsFalse(button.Enabled);
ErrorProvider warningProvider = GetWarningProvider(view);
Assert.IsEmpty(warningProvider.GetError(button));
// When
calculation.NotifyObservers();
// Then
Assert.IsTrue(buttonTester.Properties.Enabled);
Assert.AreEqual(assemblyResultOutdatedWarning, warningProvider.GetError(button));
}
}
public void Validate_ValidCalculationInputAndHydraulicBoundaryDatabase_ReturnsTrue()
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(2, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[1]);
});
Assert.IsTrue(isValid);
mockRepository.VerifyAll();
}
public void GivenFormWithAssemblyResultPerSectionView_WhenCalculationNotifiesObservers_ThenRefreshButtonEnabledAndWarningSet()
{
// Given
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllFailureMechanismSectionsAndResults(
new Random(21).NextEnumValue <AssessmentSectionComposition>());
var calculation = new TestHeightStructuresCalculationScenario();
assessmentSection.HeightStructures.CalculationsGroup.Children.Add(calculation);
using (new AssemblyToolCalculatorFactoryConfig())
using (AssemblyResultPerSectionView view = ShowAssemblyResultPerSectionView(assessmentSection))
{
// Precondition
ButtonTester buttonTester = GetRefreshAssemblyResultButtonTester();
Button button = buttonTester.Properties;
Assert.IsFalse(button.Enabled);
ErrorProvider warningProvider = GetWarningProvider(view);
Assert.IsEmpty(warningProvider.GetError(button));
// When
calculation.NotifyObservers();
// Then
Assert.IsTrue(buttonTester.Properties.Enabled);
Assert.AreEqual(assemblyResultOutdatedWarning, warningProvider.GetError(button));
}
}
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 Calculate_PreprocessorDirectorySet_InputPropertiesCorrectlySentToCalculator(bool usePreprocessor)
{
// Setup
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
calculationSettings);
// Assert
StructuresOvertoppingCalculationInput[] calculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, calculationInputs.Length);
StructuresOvertoppingCalculationInput actualInput = calculationInputs[0];
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
public void UpdateStructuresWithImportedData_SectionResultWithStructureImportedStructureWithSameIdRemoved_UpdatesCalculationInput()
{
// Setup
const string sameId = "id";
var originalMatchingPoint = new Point2D(0, 0);
HeightStructure removedStructure = new TestHeightStructure(originalMatchingPoint, sameId);
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = removedStructure
}
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
failureMechanism.HeightStructures.AddRange(new[]
{
removedStructure
}, sourceFilePath);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection(new[]
{
originalMatchingPoint,
new Point2D(10, 10)
})
});
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(Enumerable.Empty <HeightStructure>(),
sourceFilePath);
// Assert
CollectionAssert.AreEqual(new IObservable[]
{
failureMechanism.HeightStructures,
calculation.InputParameters
}, affectedObjects);
}
public void UpdateStructuresWithImportedData_CalculationWithSameReference_OnlyReturnsDistinctCalculationInput()
{
// Setup
const string affectedId = "affectedId";
var affectedStructure = new TestHeightStructure(affectedId, "Old name");
var affectedCalculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = affectedStructure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
affectedCalculation,
affectedCalculation
}
}
};
StructureCollection <HeightStructure> structures = failureMechanism.HeightStructures;
structures.AddRange(new[]
{
affectedStructure
}, sourceFilePath);
var structureToUpdateFrom = new TestHeightStructure(affectedId, "New name");
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
structureToUpdateFrom
}, sourceFilePath);
// Assert
CollectionAssert.AreEquivalent(new IObservable[]
{
structures,
affectedStructure,
affectedCalculation.InputParameters
}, affectedObjects);
}
public void ContextMenuStrip_FailureMechanismWithCalculationsContainingIllustrationPoints_ContextMenuItemClearIllustrationPointsEnabled()
{
// Setup
var calculationWithIllustrationPoints = new TestHeightStructuresCalculationScenario
{
Output = new TestStructuresOutput(new TestGeneralResultFaultTreeIllustrationPoint())
};
var calculationWithOutput = new TestHeightStructuresCalculationScenario
{
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculationWithIllustrationPoints,
calculationWithOutput,
new TestHeightStructuresCalculationScenario()
}
}
};
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new HeightStructuresFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Call
ToolStripItem toolStripItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
// Assert
Assert.IsTrue(toolStripItem.Enabled);
}
}
}
public void UpdateStructuresWithImportedData_CalculationWithRemovedStructure_UpdatesCalculation()
{
// Setup
const string removedId = "sameId";
HeightStructure structure = new TestHeightStructure(removedId, "original structure");
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
StructureCollection <HeightStructure> targetDataCollection =
failureMechanism.HeightStructures;
targetDataCollection.AddRange(new[]
{
structure
}, sourceFilePath);
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(Enumerable.Empty <HeightStructure>(),
sourceFilePath);
// Assert
Assert.IsFalse(calculation.HasOutput);
Assert.IsNull(calculation.InputParameters.Structure);
CollectionAssert.AreEqual(new IObservable[]
{
targetDataCollection,
calculation,
calculation.InputParameters
}, affectedObjects);
}
public void UpdateStructuresWithImportedData_CalculationWithStructureImportedStructureWithSameId_UpdatesCalculationInput()
{
// Setup
const string sameId = "sameId";
HeightStructure readStructure = new TestHeightStructure(sameId, "new structure");
HeightStructure structure = new TestHeightStructure(sameId, "original structure");
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
failureMechanism.HeightStructures.AddRange(new[]
{
structure
}, sourceFilePath);
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readStructure
},
sourceFilePath);
// Assert
Assert.IsTrue(calculation.HasOutput);
AssertHeightStructures(readStructure, structure);
CollectionAssert.AreEqual(new IObservable[]
{
failureMechanism.HeightStructures,
structure,
calculation.InputParameters
}, affectedObjects);
}
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 Calculate_ValidCalculationInputAndForeshoreWithInvalidBreakWater_LogStartAndEndAndReturnOutput(double height)
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository);
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(new TestStructuresCalculator <StructuresOvertoppingCalculationInput>());
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001),
ForeshoreProfile = new TestForeshoreProfile(true),
UseBreakWater = false,
UseForeshore = true
}
};
// Call
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
Action call = () => new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
CreateCalculationSettings());
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
StringAssert.StartsWith("Hoogte kunstwerk berekening is uitgevoerd op de tijdelijke locatie", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
Assert.IsNotNull(calculation.Output);
}
mockRepository.VerifyAll();
}
public void UpdateStructuresWithImportedData_CalculationWithOutputAndStructure_CalculationUpdatedAndReturnsAffectedObject()
{
// Setup
var structure = new TestHeightStructure();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
failureMechanism.HeightStructures.AddRange(new[]
{
structure
}, sourceFilePath);
var strategy = new HeightStructureReplaceDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(Enumerable.Empty <HeightStructure>(),
sourceFilePath).ToArray();
// Assert
Assert.IsFalse(calculation.HasOutput);
Assert.IsNull(calculation.InputParameters.Structure);
CollectionAssert.AreEquivalent(new IObservable[]
{
calculation,
calculation.InputParameters,
failureMechanism.HeightStructures
}, affectedObjects);
}
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 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 Validate_DistributionStandardDeviationInvalid_LogsErrorAndReturnsFalse(double deviationOne, double deviationTwo,
double deviationThree, double deviationFour,
double deviationFive, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De standaardafwijking voor '{parameterName}' moet groter zijn dan of gelijk zijn aan 0.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
calculation.InputParameters.ModelFactorSuperCriticalFlow.StandardDeviation = (RoundedDouble)deviationOne;
calculation.InputParameters.LevelCrestStructure.StandardDeviation = (RoundedDouble)deviationTwo;
calculation.InputParameters.AllowedLevelIncreaseStorage.StandardDeviation = (RoundedDouble)deviationThree;
calculation.InputParameters.FlowWidthAtBottomProtection.StandardDeviation = (RoundedDouble)deviationFour;
calculation.InputParameters.WidthFlowApertures.StandardDeviation = (RoundedDouble)deviationFive;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void Validate_LogNormalDistributionMeanInvalid_LogsErrorAndReturnsFalse(double meanOne, double meanTwo, double meanThree,
double meanFour, double meanFive, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De verwachtingswaarde voor '{parameterName}' moet een positief getal zijn.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
calculation.InputParameters.StormDuration.Mean = (RoundedDouble)meanOne;
calculation.InputParameters.AllowedLevelIncreaseStorage.Mean = (RoundedDouble)meanTwo;
calculation.InputParameters.StorageStructureArea.Mean = (RoundedDouble)meanThree;
calculation.InputParameters.FlowWidthAtBottomProtection.Mean = (RoundedDouble)meanFour;
calculation.InputParameters.CriticalOvertoppingDischarge.Mean = (RoundedDouble)meanFive;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities()
{
// Setup
StructuresCalculationScenario <HeightStructuresInput> calculation = new TestHeightStructuresCalculationScenario();
calculation.InputParameters.Structure = null;
calculation.InputParameters.HydraulicBoundaryLocation = null;
var failureMechanism = new HeightStructuresFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "A"
});
failureMechanism.CalculationsGroup.Children.Add(calculation);
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(1, childGroupEntities.Length);
CalculationGroupEntity childGroupEntity = childGroupEntities[0];
Assert.AreEqual("A", childGroupEntity.Name);
Assert.AreEqual(0, childGroupEntity.Order);
HeightStructuresCalculationEntity[] calculationEntities = entity.CalculationGroupEntity.HeightStructuresCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
HeightStructuresCalculationEntity calculationEntity = calculationEntities[0];
Assert.AreEqual("Nieuwe berekening", calculationEntity.Name);
Assert.AreEqual(1, calculationEntity.Order);
}
public void Validate_DistributionVariationCoefficientInvalid_LogsErrorAndReturnsFalse(
double coefficientOne, double coefficientTwo, double coefficientThree, string parameterName)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
string expectedValidationMessage = $"De variatiecoëfficiënt voor '{parameterName}' moet groter zijn dan of gelijk zijn aan 0.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2)
}
};
calculation.InputParameters.StormDuration.CoefficientOfVariation = (RoundedDouble)coefficientOne;
calculation.InputParameters.StorageStructureArea.CoefficientOfVariation = (RoundedDouble)coefficientTwo;
calculation.InputParameters.CriticalOvertoppingDischarge.CoefficientOfVariation = (RoundedDouble)coefficientThree;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void CreateInstance_WithContext_NewPropertiesWithFailureMechanismContextAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario();
var failureMechanism = new HeightStructuresFailureMechanism();
var context = new HeightStructuresInputContext(calculation.InputParameters, calculation, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <HeightStructuresInputContextProperties>(objectProperties);
Assert.AreSame(context, objectProperties.Data);
mocks.VerifyAll();
}
public void Validate_StructureNormalOrientationInvalid_ReturnsFalse()
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
const string expectedValidationMessage = "De waarde voor 'Oriëntatie' moet een concreet getal zijn.";
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
Structure = new TestHeightStructure()
}
};
calculation.InputParameters.StructureNormalOrientation = RoundedDouble.NaN;
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual(expectedValidationMessage, msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
private static HeightStructuresFailureMechanism CreateHeightStructuresFailureMechanismWithAllUpdateForeshoreProfileScenarios(
ForeshoreProfile unaffectedForeshoreProfile)
{
HeightStructuresFailureMechanism heightStructuresFailureMechanism =
TestDataGenerator.GetHeightStructuresFailureMechanismWithAlLCalculationConfigurations();
heightStructuresFailureMechanism.ForeshoreProfiles.AddRange(new[]
{
unaffectedForeshoreProfile
}, sourceFilePath);
var unaffectedCalculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = unaffectedForeshoreProfile
},
Output = new TestStructuresOutput()
};
heightStructuresFailureMechanism.CalculationsGroup.Children.Add(unaffectedCalculation);
return(heightStructuresFailureMechanism);
}
public void Validate_UsesBreakWaterAndHasInvalidBreakWaterSettings_LogsErrorAndReturnsFalse(double breakWaterHeight)
{
// Setup
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new HeightStructuresFailureMechanism(),
mockRepository,
validHydraulicBoundaryDatabaseFilePath);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = new HydraulicBoundaryLocation(1, "name", 2, 2),
ForeshoreProfile = new TestForeshoreProfile(new BreakWater(BreakWaterType.Dam, breakWaterHeight)),
UseBreakWater = true
}
};
// Call
var isValid = false;
Action call = () => isValid = HeightStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("De waarde voor 'hoogte' van de dam moet een concreet getal zijn.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mockRepository.VerifyAll();
}
public void GivenAssessmentSectionResultObserverWithAttachedObserver_WhenHeightStructuresCalculationNotified_ThenAttachedObserverNotified()
{
// Given
AssessmentSection assessmentSection = CreateAssessmentSection();
var calculation = new TestHeightStructuresCalculationScenario();
assessmentSection.HeightStructures.CalculationsGroup.Children.Add(calculation);
using (var resultObserver = new AssessmentSectionResultObserver(assessmentSection))
{
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
resultObserver.Attach(observer);
// When
calculation.NotifyObservers();
// Then
mocks.VerifyAll();
}
}
private HeightStructuresFailureMechanism CreateFullyConfiguredFailureMechanism()
{
var section1 = new FailureMechanismSection("A", new[]
{
new Point2D(-1, 0),
new Point2D(2, 0)
});
var section2 = new FailureMechanismSection("B", new[]
{
new Point2D(2, 0),
new Point2D(4, 0)
});
var structure1 = new TestHeightStructure(new Point2D(1, 0), "Id 1,0");
var structure2 = new TestHeightStructure(new Point2D(3, 0), "Id 3,0");
var profile = new TestForeshoreProfile();
StructuresCalculation <HeightStructuresInput> calculation1 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
},
Output = new TestStructuresOutput()
};
StructuresCalculation <HeightStructuresInput> calculation2 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure2
}
};
StructuresCalculation <HeightStructuresInput> calculation3 = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
ForeshoreProfile = profile,
Structure = structure1
}
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation1,
new CalculationGroup
{
Children =
{
calculation2
}
},
calculation3
}
}
};
failureMechanism.ForeshoreProfiles.AddRange(new[]
{
profile
}, "path");
failureMechanism.HeightStructures.AddRange(new[]
{
structure1,
structure2
}, "someLocation");
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section1,
section2
});
return(failureMechanism);
}
public void UpdateStructuresWithImportedData_MultipleCalculationWithStructuresOneWithRemovedStructure_OnlyUpdatesCalculationWithRemovedStructure()
{
// Setup
const string removedId = "affectedId";
const string unaffectedId = "unaffectedId";
const string unaffectedStructureName = "unaffectedStructure";
var removedStructure = new TestHeightStructure(removedId, "Old name");
var unaffectedStructure = new TestHeightStructure(unaffectedId, unaffectedStructureName);
var affectedCalculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = removedStructure
},
Output = new TestStructuresOutput()
};
var unaffectedCalculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = unaffectedStructure
},
Output = new TestStructuresOutput()
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
affectedCalculation,
unaffectedCalculation
}
}
};
StructureCollection <HeightStructure> targetDataCollection = failureMechanism.HeightStructures;
targetDataCollection.AddRange(new[]
{
removedStructure,
unaffectedStructure
}, sourceFilePath);
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
HeightStructure readUnaffectedStructure = new TestHeightStructure(unaffectedId, unaffectedStructureName);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readUnaffectedStructure
}, sourceFilePath);
// Assert
Assert.IsFalse(affectedCalculation.HasOutput);
Assert.IsNull(affectedCalculation.InputParameters.Structure);
Assert.IsTrue(unaffectedCalculation.HasOutput);
HeightStructure inputParametersUnaffectedStructure = unaffectedCalculation.InputParameters.Structure;
Assert.AreSame(unaffectedStructure, inputParametersUnaffectedStructure);
AssertHeightStructures(readUnaffectedStructure, inputParametersUnaffectedStructure);
CollectionAssert.AreEquivalent(new IObservable[]
{
affectedCalculation,
affectedCalculation.InputParameters,
targetDataCollection
}, affectedObjects);
}
public void Calculate_CalculationFailedWithoutExceptionAndWithLastErrorPresent_LogErrorAndThrowException()
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>
{
LastErrorFileContent = "An error occurred"
};
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001)
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var exceptionThrown = false;
string exceptionMessage = string.Empty;
// Call
Action call = () =>
{
try
{
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
CreateCalculationSettings());
}
catch (HydraRingCalculationException e)
{
exceptionThrown = true;
exceptionMessage = e.Message;
}
};
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
StringAssert.StartsWith($"De berekening voor hoogte kunstwerk '{calculation.Name}' is mislukt. Bekijk het foutrapport door op details te klikken.", msgs[1]);
StringAssert.StartsWith("Hoogte kunstwerk berekening is uitgevoerd op de tijdelijke locatie", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
});
Assert.IsTrue(exceptionThrown);
Assert.IsNull(calculation.Output);
Assert.AreEqual(calculator.LastErrorFileContent, exceptionMessage);
}
mockRepository.VerifyAll();
}
public void UpdateStructuresWithImportedData_SectionResultWithStructureImportedStructureWithSameId_UpdatesCalculationInput()
{
// Setup
const string sameId = "sameId";
var originalMatchingPoint = new Point2D(0, 0);
var updatedMatchingPoint = new Point2D(20, 20);
HeightStructure readStructure = new TestHeightStructure(updatedMatchingPoint, sameId);
HeightStructure structure = new TestHeightStructure(originalMatchingPoint, sameId);
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structure
}
};
var failureMechanism = new HeightStructuresFailureMechanism
{
CalculationsGroup =
{
Children =
{
calculation
}
}
};
failureMechanism.HeightStructures.AddRange(new[]
{
structure
}, sourceFilePath);
var intersectionPoint = new Point2D(10, 10);
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
new FailureMechanismSection("OldSection", new[]
{
originalMatchingPoint,
intersectionPoint
}),
new FailureMechanismSection("NewSection", new[]
{
intersectionPoint,
updatedMatchingPoint
})
});
var strategy = new HeightStructureUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateStructuresWithImportedData(new[]
{
readStructure
},
sourceFilePath);
// Assert
AssertHeightStructures(readStructure, structure);
CollectionAssert.AreEqual(new IObservable[]
{
failureMechanism.HeightStructures,
structure,
calculation.InputParameters
}, affectedObjects);
}
public void RemoveStructure_FullyConfiguredFailureMechanism_RemovesStructureAndClearsDependentData()
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var structureToRemove = new TestHeightStructure(new Point2D(0, 0), "id1");
var structureToKeep = new TestHeightStructure(new Point2D(2, 2), "id2");
failureMechanism.HeightStructures.AddRange(new[]
{
structureToRemove,
structureToKeep
}, "path/to/structures");
var calculationWithOutput = new TestHeightStructuresCalculationScenario
{
Output = new TestStructuresOutput()
};
var calculationWithStructureToRemove = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToRemove
}
};
var calculationWithStructureToKeepAndOutput = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToKeep
},
Output = new TestStructuresOutput()
};
var calculationWithStructureToRemoveAndOutput = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
Structure = structureToRemove
},
Output = new TestStructuresOutput()
};
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculationWithOutput,
calculationWithStructureToRemove,
calculationWithStructureToKeepAndOutput,
calculationWithStructureToRemoveAndOutput
});
// Call
IEnumerable <IObservable> affectedObjects = HeightStructuresDataSynchronizationService.RemoveStructure(
structureToRemove, failureMechanism);
// Assert
// Note: To make sure the clear is performed regardless of what is done with
// the return result, no ToArray() should be called before these assertions:
CollectionAssert.DoesNotContain(failureMechanism.HeightStructures, structureToRemove);
Assert.IsNull(calculationWithStructureToRemove.InputParameters.Structure);
Assert.IsNull(calculationWithStructureToRemoveAndOutput.InputParameters.Structure);
Assert.IsNull(calculationWithStructureToRemoveAndOutput.Output);
Assert.IsNotNull(calculationWithOutput.Output);
Assert.IsNotNull(calculationWithStructureToKeepAndOutput.Output);
Assert.IsNotNull(calculationWithStructureToKeepAndOutput.InputParameters.Structure);
IObservable[] expectedAffectedObjects =
{
calculationWithStructureToRemove.InputParameters,
calculationWithStructureToRemoveAndOutput,
calculationWithStructureToRemoveAndOutput.InputParameters,
failureMechanism.HeightStructures
};
CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
}
public void Calculate_VariousCalculationsWithBreakWater_InputPropertiesCorrectlySentToCalculator(BreakWaterType breakWaterType)
{
// Setup
var failureMechanism = new HeightStructuresFailureMechanism();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mockRepository);
var calculator = new TestStructuresCalculator <StructuresOvertoppingCalculationInput>();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresOvertoppingCalculationInput>(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var calculation = new TestHeightStructuresCalculationScenario
{
InputParameters =
{
HydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First(hl => hl.Id == 1300001),
ForeshoreProfile = new TestForeshoreProfile(true)
{
BreakWater =
{
Type = breakWaterType
}
}
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new HeightStructuresCalculationService().Calculate(calculation,
failureMechanism.GeneralInput,
CreateCalculationSettings());
// Assert
StructuresOvertoppingCalculationInput[] overtoppingCalculationInputs = calculator.ReceivedInputs.ToArray();
Assert.AreEqual(1, overtoppingCalculationInputs.Length);
GeneralHeightStructuresInput generalInput = failureMechanism.GeneralInput;
HeightStructuresInput input = calculation.InputParameters;
var expectedInput = new StructuresOvertoppingCalculationInput(
1300001,
input.StructureNormalOrientation,
input.ForeshoreGeometry.Select(c => new HydraRingForelandPoint(c.X, c.Y)),
new HydraRingBreakWater(BreakWaterTypeHelper.GetHydraRingBreakWaterType(breakWaterType), input.BreakWater.Height),
generalInput.GravitationalAcceleration,
generalInput.ModelFactorOvertoppingFlow.Mean, generalInput.ModelFactorOvertoppingFlow.StandardDeviation,
input.LevelCrestStructure.Mean, input.LevelCrestStructure.StandardDeviation,
input.StructureNormalOrientation,
input.ModelFactorSuperCriticalFlow.Mean, input.ModelFactorSuperCriticalFlow.StandardDeviation,
input.AllowedLevelIncreaseStorage.Mean, input.AllowedLevelIncreaseStorage.StandardDeviation,
generalInput.ModelFactorStorageVolume.Mean, generalInput.ModelFactorStorageVolume.StandardDeviation,
input.StorageStructureArea.Mean, input.StorageStructureArea.CoefficientOfVariation,
generalInput.ModelFactorInflowVolume,
input.FlowWidthAtBottomProtection.Mean, input.FlowWidthAtBottomProtection.StandardDeviation,
input.CriticalOvertoppingDischarge.Mean, input.CriticalOvertoppingDischarge.CoefficientOfVariation,
input.FailureProbabilityStructureWithErosion,
input.WidthFlowApertures.Mean, input.WidthFlowApertures.StandardDeviation,
input.DeviationWaveDirection,
input.StormDuration.Mean, input.StormDuration.CoefficientOfVariation);
StructuresOvertoppingCalculationInput actualInput = overtoppingCalculationInputs[0];
HydraRingDataEqualityHelper.AreEqual(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
}
mockRepository.VerifyAll();
}
