public void Constructor_DefaultProperties_ExpectedValues()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
// Call
var mergeData = new AssessmentSectionMergeData(assessmentSection,
new AssessmentSectionMergeData.ConstructionProperties());
// Assert
Assert.AreSame(assessmentSection, mergeData.AssessmentSection);
Assert.IsFalse(mergeData.MergePiping);
Assert.IsFalse(mergeData.MergeGrassCoverErosionInwards);
Assert.IsFalse(mergeData.MergeMacroStabilityInwards);
Assert.IsFalse(mergeData.MergeMicrostability);
Assert.IsFalse(mergeData.MergeStabilityStoneCover);
Assert.IsFalse(mergeData.MergeWaveImpactAsphaltCover);
Assert.IsFalse(mergeData.MergeWaterPressureAsphaltCover);
Assert.IsFalse(mergeData.MergeGrassCoverErosionOutwards);
Assert.IsFalse(mergeData.MergeGrassCoverSlipOffOutwards);
Assert.IsFalse(mergeData.MergeGrassCoverSlipOffInwards);
Assert.IsFalse(mergeData.MergeHeightStructures);
Assert.IsFalse(mergeData.MergeClosingStructures);
Assert.IsFalse(mergeData.MergePipingStructure);
Assert.IsFalse(mergeData.MergeStabilityPointStructures);
Assert.IsFalse(mergeData.MergeDuneErosion);
CollectionAssert.IsEmpty(mergeData.MergeSpecificFailureMechanisms);
}
/// <summary>
/// Validates the <see cref="AssessmentSectionMergeData"/>.
/// </summary>
/// <param name="mergeData">The <see cref="AssessmentSectionMergeData"/> to validate.</param>
/// <exception cref="ArgumentException">Thrown when <paramref name="mergeData"/> is invalid.</exception>
private static void ValidateMergeData(AssessmentSectionMergeData mergeData)
{
AssessmentSection sourceAssessmentSection = mergeData.AssessmentSection;
if (!mergeData.MergeSpecificFailureMechanisms.All(fp => sourceAssessmentSection.SpecificFailureMechanisms.Contains(fp)))
{
throw new ArgumentException($"{nameof(AssessmentSectionMergeData.MergeSpecificFailureMechanisms)} must contain items of " +
$"the assessment section in {nameof(mergeData)}.");
}
}
public void GivenValidDialog_WhenGetMergeDataCalledAndAllDataSelectedAndImportPressed_ThenReturnsSelectedData()
{
// Given
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsAndSpecificFailureMechanisms();
DialogBoxHandler = (formName, wnd) =>
{
using (var formTester = new FormTester(formName))
{
var dialog = (AssessmentSectionMergeDataProviderDialog)formTester.TheObject;
var dataGridView = (DataGridView) new ControlTester("dataGridView", dialog).TheObject;
DataGridViewRowCollection rows = dataGridView.Rows;
foreach (DataGridViewRow row in rows)
{
row.Cells[isSelectedIndex].Value = true;
}
var button = new ButtonTester("importButton", formName);
button.Click();
}
};
using (var dialogParent = new Form())
using (var dialog = new AssessmentSectionMergeDataProviderDialog(dialogParent))
{
// When
AssessmentSectionMergeData result = dialog.GetMergeData(assessmentSection);
// Then
Assert.AreSame(assessmentSection, result.AssessmentSection);
Assert.IsTrue(result.MergePiping);
Assert.IsTrue(result.MergeGrassCoverErosionInwards);
Assert.IsTrue(result.MergeMacroStabilityInwards);
Assert.IsTrue(result.MergeMicrostability);
Assert.IsTrue(result.MergeStabilityStoneCover);
Assert.IsTrue(result.MergeWaveImpactAsphaltCover);
Assert.IsTrue(result.MergeWaterPressureAsphaltCover);
Assert.IsTrue(result.MergeGrassCoverErosionOutwards);
Assert.IsTrue(result.MergeGrassCoverSlipOffOutwards);
Assert.IsTrue(result.MergeGrassCoverSlipOffInwards);
Assert.IsTrue(result.MergeHeightStructures);
Assert.IsTrue(result.MergeClosingStructures);
Assert.IsTrue(result.MergePipingStructure);
Assert.IsTrue(result.MergeStabilityPointStructures);
Assert.IsTrue(result.MergeDuneErosion);
CollectionAssert.AreEqual(assessmentSection.SpecificFailureMechanisms, result.MergeSpecificFailureMechanisms);
}
}
private void PerformMerge(AssessmentSection assessmentSection, AssessmentSectionMergeData mergeData)
{
log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_started);
try
{
mergeHandler.PerformMerge(assessmentSection, mergeData);
log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_successful);
}
catch (Exception e)
{
log.Error(Resources.AssessmentSectionMerger_PerformMerge_Unexpected_error_occurred_during_merge, e);
log.Error(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_failed);
}
}
public void GivenMatchedAssessmentSection_WhenMergeHandlerThrowsException_ThenMergeFailedAndLogged()
{
// Given
var originalAssessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
var assessmentSectionToMerge = new AssessmentSection(AssessmentSectionComposition.Dike);
var mergeData = new AssessmentSectionMergeData(assessmentSectionToMerge, CreateDefaultConstructionProperties());
var mocks = new MockRepository();
var filePathProvider = mocks.StrictMock <IAssessmentSectionMergeFilePathProvider>();
filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
var assessmentSectionProvider = mocks.StrictMock <IAssessmentSectionProvider>();
assessmentSectionProvider.Expect(asp => asp.GetAssessmentSection(null)).IgnoreArguments()
.Return(assessmentSectionToMerge);
var comparer = mocks.StrictMock <IAssessmentSectionMergeComparer>();
comparer.Expect(c => c.Compare(originalAssessmentSection, assessmentSectionToMerge)).Return(true);
var mergeDataProvider = mocks.StrictMock <IAssessmentSectionMergeDataProvider>();
mergeDataProvider.Expect(mdp => mdp.GetMergeData(null)).IgnoreArguments().Return(mergeData);
var mergeHandler = mocks.StrictMock <IAssessmentSectionMergeHandler>();
mergeHandler.Expect(mh => mh.PerformMerge(originalAssessmentSection, mergeData)).Throw(new Exception());
mocks.ReplayAll();
var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
// When
void Call() => merger.StartMerge(originalAssessmentSection);
// Then
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(Call, messages =>
{
Assert.AreEqual(3, messages.Count());
Assert.AreEqual("Samenvoegen van trajectinformatie is gestart.", messages.ElementAt(0).Item1);
Tuple <string, Level, Exception> expectedLog = messages.ElementAt(1);
Assert.AreEqual("Er is een onverwachte fout opgetreden tijdens het samenvoegen van de trajecten.", expectedLog.Item1);
Assert.AreEqual(Level.Error, expectedLog.Item2);
Exception loggedException = expectedLog.Item3;
Assert.IsInstanceOf <Exception>(loggedException);
Assert.AreEqual("Samenvoegen van trajectinformatie is mislukt.", messages.ElementAt(2).Item1);
});
mocks.VerifyAll();
}
public void Constructor_PropertiesSet_ExpectedValues()
{
// Setup
var random = new Random(21);
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
var constructionProperties = new AssessmentSectionMergeData.ConstructionProperties
{
MergePiping = random.NextBoolean(),
MergeGrassCoverErosionInwards = random.NextBoolean(),
MergeMacroStabilityInwards = random.NextBoolean(),
MergeMicrostability = random.NextBoolean(),
MergeStabilityStoneCover = random.NextBoolean(),
MergeWaveImpactAsphaltCover = random.NextBoolean(),
MergeWaterPressureAsphaltCover = random.NextBoolean(),
MergeGrassCoverErosionOutwards = random.NextBoolean(),
MergeGrassCoverSlipOffOutwards = random.NextBoolean(),
MergeGrassCoverSlipOffInwards = random.NextBoolean(),
MergeHeightStructures = random.NextBoolean(),
MergeClosingStructures = random.NextBoolean(),
MergePipingStructure = random.NextBoolean(),
MergeStabilityPointStructures = random.NextBoolean(),
MergeDuneErosion = random.NextBoolean()
};
// Call
var mergeData = new AssessmentSectionMergeData(assessmentSection, constructionProperties);
// Assert
Assert.AreSame(assessmentSection, mergeData.AssessmentSection);
Assert.AreEqual(constructionProperties.MergePiping, mergeData.MergePiping);
Assert.AreEqual(constructionProperties.MergeGrassCoverErosionInwards, mergeData.MergeGrassCoverErosionInwards);
Assert.AreEqual(constructionProperties.MergeMacroStabilityInwards, mergeData.MergeMacroStabilityInwards);
Assert.AreEqual(constructionProperties.MergeMicrostability, mergeData.MergeMicrostability);
Assert.AreEqual(constructionProperties.MergeStabilityStoneCover, mergeData.MergeStabilityStoneCover);
Assert.AreEqual(constructionProperties.MergeWaveImpactAsphaltCover, mergeData.MergeWaveImpactAsphaltCover);
Assert.AreEqual(constructionProperties.MergeWaterPressureAsphaltCover, mergeData.MergeWaterPressureAsphaltCover);
Assert.AreEqual(constructionProperties.MergeGrassCoverErosionOutwards, mergeData.MergeGrassCoverErosionOutwards);
Assert.AreEqual(constructionProperties.MergeGrassCoverSlipOffOutwards, mergeData.MergeGrassCoverSlipOffOutwards);
Assert.AreEqual(constructionProperties.MergeGrassCoverSlipOffInwards, mergeData.MergeGrassCoverSlipOffInwards);
Assert.AreEqual(constructionProperties.MergeHeightStructures, mergeData.MergeHeightStructures);
Assert.AreEqual(constructionProperties.MergeClosingStructures, mergeData.MergeClosingStructures);
Assert.AreEqual(constructionProperties.MergePipingStructure, mergeData.MergePipingStructure);
Assert.AreEqual(constructionProperties.MergeStabilityPointStructures, mergeData.MergeStabilityPointStructures);
Assert.AreEqual(constructionProperties.MergeDuneErosion, mergeData.MergeDuneErosion);
Assert.AreSame(constructionProperties.MergeSpecificFailureMechanisms, mergeData.MergeSpecificFailureMechanisms);
}
/// <summary>
/// Performs the merge of <paramref name="assessmentSection"/>.
/// </summary>
/// <param name="assessmentSection">The assessment section to perform the merge on.</param>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="assessmentSection"/>
/// is <c>null</c>.</exception>
public void StartMerge(AssessmentSection assessmentSection)
{
if (assessmentSection == null)
{
throw new ArgumentNullException(nameof(assessmentSection));
}
string filePath = filePathProvider.GetFilePath();
if (filePath == null)
{
LogCancelMessage();
return;
}
AssessmentSection readAssessmentSection;
try
{
readAssessmentSection = assessmentSectionProvider.GetAssessmentSection(filePath);
}
catch (AssessmentSectionProviderException)
{
return;
}
bool assessmentSectionMatchesReadAssessmentSection = mergeComparer.Compare(assessmentSection, readAssessmentSection);
if (!assessmentSectionMatchesReadAssessmentSection)
{
log.Error(Resources.AssessmentSectionMerger_No_matching_AssessmentSection);
return;
}
AssessmentSectionMergeData mergeData = mergeDataProvider.GetMergeData(readAssessmentSection);
if (mergeData == null)
{
LogCancelMessage();
return;
}
PerformMerge(assessmentSection, mergeData);
}
public void GivenValidDialog_WhenGetMergeDataCalledAndImportPressed_ThenReturnsSelectedData()
{
// Given
AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsAndSpecificFailureMechanisms();
DialogBoxHandler = (formName, wnd) =>
{
using (new FormTester(formName))
{
var button = new ButtonTester("importButton", formName);
button.Click();
}
};
using (var dialogParent = new Form())
using (var dialog = new AssessmentSectionMergeDataProviderDialog(dialogParent))
{
// When
AssessmentSectionMergeData result = dialog.GetMergeData(assessmentSection);
// Then
Assert.AreSame(assessmentSection, result.AssessmentSection);
Assert.IsFalse(result.MergePiping);
Assert.IsFalse(result.MergeGrassCoverErosionInwards);
Assert.IsFalse(result.MergeMacroStabilityInwards);
Assert.IsFalse(result.MergeMicrostability);
Assert.IsFalse(result.MergeStabilityStoneCover);
Assert.IsFalse(result.MergeWaveImpactAsphaltCover);
Assert.IsFalse(result.MergeWaterPressureAsphaltCover);
Assert.IsFalse(result.MergeGrassCoverErosionOutwards);
Assert.IsFalse(result.MergeGrassCoverSlipOffOutwards);
Assert.IsFalse(result.MergeGrassCoverSlipOffInwards);
Assert.IsFalse(result.MergeHeightStructures);
Assert.IsFalse(result.MergeClosingStructures);
Assert.IsFalse(result.MergePipingStructure);
Assert.IsFalse(result.MergeStabilityPointStructures);
Assert.IsFalse(result.MergeDuneErosion);
CollectionAssert.IsEmpty(result.MergeSpecificFailureMechanisms);
}
}
public void PerformMerge(AssessmentSection targetAssessmentSection, AssessmentSectionMergeData mergeData)
{
if (targetAssessmentSection == null)
{
throw new ArgumentNullException(nameof(targetAssessmentSection));
}
if (mergeData == null)
{
throw new ArgumentNullException(nameof(mergeData));
}
ValidateMergeData(mergeData);
IEnumerable <IObservable> changedObjects = MergeHydraulicBoundaryLocationCalculations(targetAssessmentSection, mergeData.AssessmentSection);
MergeFailureMechanisms(targetAssessmentSection, mergeData);
MergeSpecificFailureMechanism(targetAssessmentSection, mergeData.MergeSpecificFailureMechanisms);
AfterMerge(changedObjects);
}
public void GivenMatchedAssessmentSection_WhenAllDataValid_ThenMergePerformedAndLogged()
{
// Given
var filePath = "Filepath";
var originalAssessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
var assessmentSectionToMerge = new AssessmentSection(AssessmentSectionComposition.Dike);
var mergeData = new AssessmentSectionMergeData(assessmentSectionToMerge, CreateDefaultConstructionProperties());
var mocks = new MockRepository();
var filePathProvider = mocks.StrictMock <IAssessmentSectionMergeFilePathProvider>();
filePathProvider.Expect(helper => helper.GetFilePath()).Return(filePath);
var assessmentSectionProvider = mocks.StrictMock <IAssessmentSectionProvider>();
assessmentSectionProvider.Expect(asp => asp.GetAssessmentSection(filePath))
.Return(assessmentSectionToMerge);
var comparer = mocks.StrictMock <IAssessmentSectionMergeComparer>();
comparer.Expect(c => c.Compare(originalAssessmentSection, assessmentSectionToMerge)).Return(true);
var mergeDataProvider = mocks.StrictMock <IAssessmentSectionMergeDataProvider>();
mergeDataProvider.Expect(mdp => mdp.GetMergeData(null)).IgnoreArguments().Return(mergeData);
var mergeHandler = mocks.StrictMock <IAssessmentSectionMergeHandler>();
mergeHandler.Expect(mh => mh.PerformMerge(originalAssessmentSection, mergeData));
mocks.ReplayAll();
var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
// When
void Call() => merger.StartMerge(originalAssessmentSection);
// Then
TestHelper.AssertLogMessagesWithLevelAreGenerated(Call, new[]
{
new Tuple <string, LogLevelConstant>("Samenvoegen van trajectinformatie is gestart.", LogLevelConstant.Info),
new Tuple <string, LogLevelConstant>("Samenvoegen van trajectinformatie is gelukt.", LogLevelConstant.Info)
});
mocks.VerifyAll();
}
public void GivenValidDialog_WhenGetMergeDataCalledAndCancelPressed_ThenReturnsNull()
{
// Given
DialogBoxHandler = (formName, wnd) =>
{
using (new FormTester(formName))
{
var button = new ButtonTester("cancelButton", formName);
button.Click();
}
};
using (var dialogParent = new Form())
using (var dialog = new AssessmentSectionMergeDataProviderDialog(dialogParent))
{
// When
AssessmentSectionMergeData result = dialog.GetMergeData(TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurationsAndSpecificFailureMechanisms());
// Then
Assert.IsNull(result);
}
}
private static void MergeFailureMechanisms(AssessmentSection targetAssessmentSection, AssessmentSectionMergeData mergeData)
{
ObservableList <HydraulicBoundaryLocation> hydraulicBoundaryLocations = targetAssessmentSection.HydraulicBoundaryDatabase.Locations;
AssessmentSection sourceAssessmentSection = mergeData.AssessmentSection;
if (mergeData.MergePiping)
{
targetAssessmentSection.Piping = sourceAssessmentSection.Piping;
UpdateCalculationHydraulicBoundaryLocationReferences <PipingFailureMechanism, IPipingCalculationScenario <PipingInput>, PipingInput>(
targetAssessmentSection.Piping, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.Piping);
}
if (mergeData.MergeGrassCoverErosionInwards)
{
targetAssessmentSection.GrassCoverErosionInwards = sourceAssessmentSection.GrassCoverErosionInwards;
UpdateCalculationHydraulicBoundaryLocationReferences <GrassCoverErosionInwardsFailureMechanism, GrassCoverErosionInwardsCalculationScenario, GrassCoverErosionInwardsInput>(
targetAssessmentSection.GrassCoverErosionInwards, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.GrassCoverErosionInwards);
}
if (mergeData.MergeMacroStabilityInwards)
{
targetAssessmentSection.MacroStabilityInwards = sourceAssessmentSection.MacroStabilityInwards;
UpdateCalculationHydraulicBoundaryLocationReferences <MacroStabilityInwardsFailureMechanism, MacroStabilityInwardsCalculationScenario, MacroStabilityInwardsInput>(
targetAssessmentSection.MacroStabilityInwards, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.MacroStabilityInwards);
}
if (mergeData.MergeMicrostability)
{
targetAssessmentSection.Microstability = sourceAssessmentSection.Microstability;
LogMergeMessage(targetAssessmentSection.Microstability);
}
if (mergeData.MergeStabilityStoneCover)
{
targetAssessmentSection.StabilityStoneCover = sourceAssessmentSection.StabilityStoneCover;
UpdateCalculationHydraulicBoundaryLocationReferences <StabilityStoneCoverFailureMechanism, StabilityStoneCoverWaveConditionsCalculation, StabilityStoneCoverWaveConditionsInput>(
targetAssessmentSection.StabilityStoneCover, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.StabilityStoneCover);
}
if (mergeData.MergeWaveImpactAsphaltCover)
{
targetAssessmentSection.WaveImpactAsphaltCover = sourceAssessmentSection.WaveImpactAsphaltCover;
UpdateCalculationHydraulicBoundaryLocationReferences <WaveImpactAsphaltCoverFailureMechanism, WaveImpactAsphaltCoverWaveConditionsCalculation, WaveConditionsInput>(
targetAssessmentSection.WaveImpactAsphaltCover, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.WaveImpactAsphaltCover);
}
if (mergeData.MergeWaterPressureAsphaltCover)
{
targetAssessmentSection.WaterPressureAsphaltCover = sourceAssessmentSection.WaterPressureAsphaltCover;
LogMergeMessage(targetAssessmentSection.WaterPressureAsphaltCover);
}
if (mergeData.MergeGrassCoverErosionOutwards)
{
targetAssessmentSection.GrassCoverErosionOutwards = sourceAssessmentSection.GrassCoverErosionOutwards;
UpdateCalculationHydraulicBoundaryLocationReferences <GrassCoverErosionOutwardsFailureMechanism, GrassCoverErosionOutwardsWaveConditionsCalculation, GrassCoverErosionOutwardsWaveConditionsInput>(
targetAssessmentSection.GrassCoverErosionOutwards, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.GrassCoverErosionOutwards);
}
if (mergeData.MergeGrassCoverSlipOffOutwards)
{
targetAssessmentSection.GrassCoverSlipOffOutwards = sourceAssessmentSection.GrassCoverSlipOffOutwards;
LogMergeMessage(targetAssessmentSection.GrassCoverSlipOffOutwards);
}
if (mergeData.MergeGrassCoverSlipOffInwards)
{
targetAssessmentSection.GrassCoverSlipOffInwards = sourceAssessmentSection.GrassCoverSlipOffInwards;
LogMergeMessage(targetAssessmentSection.GrassCoverSlipOffInwards);
}
if (mergeData.MergeHeightStructures)
{
targetAssessmentSection.HeightStructures = sourceAssessmentSection.HeightStructures;
UpdateCalculationHydraulicBoundaryLocationReferences <HeightStructuresFailureMechanism, StructuresCalculationScenario <HeightStructuresInput>, HeightStructuresInput>(
targetAssessmentSection.HeightStructures, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.HeightStructures);
}
if (mergeData.MergeClosingStructures)
{
targetAssessmentSection.ClosingStructures = sourceAssessmentSection.ClosingStructures;
UpdateCalculationHydraulicBoundaryLocationReferences <ClosingStructuresFailureMechanism, StructuresCalculationScenario <ClosingStructuresInput>, ClosingStructuresInput>(
targetAssessmentSection.ClosingStructures, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.ClosingStructures);
}
if (mergeData.MergePipingStructure)
{
targetAssessmentSection.PipingStructure = sourceAssessmentSection.PipingStructure;
LogMergeMessage(targetAssessmentSection.PipingStructure);
}
if (mergeData.MergeStabilityPointStructures)
{
targetAssessmentSection.StabilityPointStructures = sourceAssessmentSection.StabilityPointStructures;
UpdateCalculationHydraulicBoundaryLocationReferences <StabilityPointStructuresFailureMechanism, StructuresCalculationScenario <StabilityPointStructuresInput>, StabilityPointStructuresInput>(
targetAssessmentSection.StabilityPointStructures, hydraulicBoundaryLocations);
LogMergeMessage(targetAssessmentSection.StabilityPointStructures);
}
if (mergeData.MergeDuneErosion)
{
targetAssessmentSection.DuneErosion = sourceAssessmentSection.DuneErosion;
LogMergeMessage(targetAssessmentSection.DuneErosion);
}
}
