public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(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;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = contextMenu.Items[contextMenuValidateAllIndex];
Assert.AreEqual("Alles &valideren", contextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.ValidateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_CalculateAllDisabled()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new WaveImpactAsphaltCoverWaveConditionsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var nodeData = new WaveImpactAsphaltCoverFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem calculateItem = contextMenu.Items[contextMenuCalculateAllIndex];
Assert.IsFalse(calculateItem.Enabled);
Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", calculateItem.ToolTipText);
}
}
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(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;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.ValidateAllIcon,
false);
}
}
}
private static void SetPropertyAndVerifyNotificationsForCalculation(Action <MacroStabilityInwardsWaterStressesProperties> setProperty,
MacroStabilityInwardsCalculation calculation)
{
// Setup
var mocks = new MockRepository();
var observable = mocks.StrictMock <IObservable>();
observable.Expect(o => o.NotifyObservers());
mocks.ReplayAll();
MacroStabilityInwardsInput input = calculation.InputParameters;
var propertyChangeHandler = new SetPropertyValueAfterConfirmationParameterTester(new[]
{
observable
});
var properties = new MacroStabilityInwardsWaterStressesProperties(input,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel(),
propertyChangeHandler);
// Call
setProperty(properties);
// Assert
Assert.IsTrue(propertyChangeHandler.Called);
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var propertyChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var input = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties());
// Call
var properties = new MacroStabilityInwardsWaterStressesProperties(input,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel(),
propertyChangeHandler);
// Assert
Assert.IsInstanceOf <ObjectProperties <MacroStabilityInwardsInput> >(properties);
Assert.AreSame(input, properties.Data);
TestHelper.AssertTypeConverter <MacroStabilityInwardsWaterStressesProperties, ExpandableObjectConverter>(
nameof(MacroStabilityInwardsWaterStressesProperties.Drainage));
TestHelper.AssertTypeConverter <MacroStabilityInwardsWaterStressesProperties, ExpandableObjectConverter>(
nameof(MacroStabilityInwardsWaterStressesProperties.LocationDaily));
TestHelper.AssertTypeConverter <MacroStabilityInwardsWaterStressesProperties, ExpandableObjectConverter>(
nameof(MacroStabilityInwardsWaterStressesProperties.LocationExtreme));
TestHelper.AssertTypeConverter <MacroStabilityInwardsWaterStressesProperties, ExpandableObjectConverter>(
nameof(MacroStabilityInwardsWaterStressesProperties.WaterStressLines));
mocks.VerifyAll();
}
public void CreateInstance_ValidData_NewPropertiesWithOutputAsData()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var scenario = new MacroStabilityInwardsCalculationScenario
{
Output = MacroStabilityInwardsOutputTestFactory.CreateOutput()
};
var context = new MacroStabilityInwardsOutputContext(scenario, failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <MacroStabilityInwardsOutputProperties>(objectProperties);
Assert.AreSame(scenario.Output, objectProperties.Data);
mocks.VerifyAll();
}
public void DynamicReadOnlyValidationMethod_OtherDikeSoilScenario_ReturnsExpectedReadOnly(MacroStabilityInwardsDikeSoilScenario dikeSoilScenario)
{
// Setup
var mocks = new MockRepository();
var propertyChangeHandler = mocks.Stub <IObservablePropertyChangeHandler>();
mocks.ReplayAll();
var input = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties())
{
DikeSoilScenario = dikeSoilScenario
};
var properties = new MacroStabilityInwardsWaterStressesProperties(input,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel(),
propertyChangeHandler);
// Call & Assert
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.AdjustPhreaticLine3And4ForUplift)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.LeakageLengthInwardsPhreaticLine3)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.LeakageLengthOutwardsPhreaticLine3)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.LeakageLengthInwardsPhreaticLine4)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.LeakageLengthOutwardsPhreaticLine4)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.PiezometricHeadPhreaticLine2Inwards)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.PiezometricHeadPhreaticLine2Outwards)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.WaterLevelRiverAverage)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.MinimumLevelPhreaticLineAtDikeTopPolder)));
Assert.IsFalse(properties.DynamicReadOnlyValidationMethod(nameof(MacroStabilityInwardsWaterStressesProperties.MinimumLevelPhreaticLineAtDikeTopRiver)));
}
public void GetUniqueDisplayNameForWaterLevelCalculations_ValidParameters_ReturnsExpectedDisplayNameForMaximumAllowableFloodingProbability(
double maximumAllowableFloodingProbability, double signalFloodingProbability, double userDefinedTargetProbability1, double userDefinedTargetProbability2, string expectedName)
{
// Setup
var hydraulicBoundaryLocationCalculations = new ObservableList <HydraulicBoundaryLocationCalculation>();
var mockRepository = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mockRepository);
assessmentSection.Stub(a => a.FailureMechanismContribution).Return(new FailureMechanismContribution(maximumAllowableFloodingProbability, signalFloodingProbability));
assessmentSection.Stub(a => a.WaterLevelCalculationsForMaximumAllowableFloodingProbability).Return(hydraulicBoundaryLocationCalculations);
assessmentSection.Stub(a => a.WaterLevelCalculationsForSignalFloodingProbability).Return(new ObservableList <HydraulicBoundaryLocationCalculation>());
assessmentSection.Stub(a => a.WaterLevelCalculationsForUserDefinedTargetProbabilities).Return(
new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability1),
new HydraulicBoundaryLocationCalculationsForTargetProbability(userDefinedTargetProbability2)
});
mockRepository.ReplayAll();
// Call
string name = TargetProbabilityCalculationsDisplayNameHelper.GetUniqueDisplayNameForWaterLevelCalculations(hydraulicBoundaryLocationCalculations,
assessmentSection);
// Assert
Assert.AreEqual(expectedName, name);
mockRepository.VerifyAll();
}
public void Constructor_ValidData_PropertiesHaveExpectedAttributeValues()
{
// Setup
var input = new MacroStabilityInwardsInput(new MacroStabilityInwardsInput.ConstructionProperties());
// Call
var properties = new MacroStabilityInwardsWaterStressLinesProperties(input,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(2, dynamicProperties.Count);
const string waterStressesCategoryName = "Waterspanningen";
PropertyDescriptor waternetExtremeProperty = dynamicProperties[0];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waternetExtremeProperty,
waterStressesCategoryName,
"Extreme omstandigheden",
"Eigenschappen van de waterspanningslijnen bij extreme omstandigheden.",
true);
PropertyDescriptor waternetDailyProperty = dynamicProperties[1];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(waternetDailyProperty,
waterStressesCategoryName,
"Dagelijkse omstandigheden",
"Eigenschappen van de waterspanningslijnen bij dagelijkse omstandigheden.",
true);
}
public void CalculateWaveHeights_ValidPathOneCalculation_LogsMessages()
{
// Setup
const string hydraulicLocationName = "name";
const string calculationIdentifier = "1/100";
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveHeightCalculator());
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var viewParent = new TestViewParentForm())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() =>
guiService.CalculateWaveHeights(new[]
{
new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(hydraulicLocationName))
}, assessmentSection, 0.01, calculationIdentifier);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(8, msgs.Length);
string activityDescription = GetWaveHeightCalculationActivityDescription(hydraulicLocationName, calculationIdentifier);
Assert.AreEqual($"{activityDescription} is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
Assert.AreEqual($"Golfhoogte berekening voor locatie 'name' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]);
StringAssert.StartsWith("Golfhoogte berekening is uitgevoerd op de tijdelijke locatie", msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
Assert.AreEqual($"{activityDescription} is gelukt.", msgs[7]);
});
}
mocks.VerifyAll();
}
public void CalculateWaveHeights_ValidPathEmptyCalculationList_NoLog()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var viewParent = new TestViewParentForm())
{
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.CalculateWaveHeights(Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), assessmentSection, 0.01, "1/100");
// Assert
TestHelper.AssertLogMessagesCount(Call, 0);
}
mocks.VerifyAll();
}
public void CalculateWaveHeights_HydraulicDatabaseDoesNotExist_LogsError()
{
// Setup
var mocks = new MockRepository();
var viewParent = mocks.Stub <IViewParent>();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
assessmentSection.HydraulicBoundaryDatabase.FilePath = "Does not exist";
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var guiService = new HydraulicBoundaryLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.CalculateWaveHeights(Enumerable.Empty <HydraulicBoundaryLocationCalculation>(), assessmentSection, 0.01, "1/100");
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(1, msgs.Length);
StringAssert.StartsWith("Berekeningen konden niet worden gestart. ", msgs.First());
});
mocks.VerifyAll();
}
public void Run_ValidPipingCalculation_PerformPipingValidationAndCalculationAndLogStartAndEnd()
{
// Setup
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
var activity = new SemiProbabilisticPipingCalculationActivity(validPipingCalculation,
new GeneralPipingInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(5, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{validPipingCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]);
});
Assert.AreEqual(ActivityState.Executed, activity.State);
Assert.IsNotNull(validPipingCalculation.Output);
}
public void Finish_ValidPipingCalculationAndRan_NotifyObserversOfPipingCalculation()
{
// Setup
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var validPipingCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <TestSemiProbabilisticPipingCalculation>(
new TestHydraulicBoundaryLocation());
validPipingCalculation.Output = null;
validPipingCalculation.Attach(observer);
var activity = new SemiProbabilisticPipingCalculationActivity(validPipingCalculation,
new GeneralPipingInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
activity.Run();
// Call
activity.Finish();
// Assert
mocks.VerifyAll();
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
var context = new StabilityPointStructuresCalculationGroupContext(new CalculationGroup(),
null,
new StabilityPointStructuresFailureMechanism(),
assessmentSection);
using (var plugin = new StabilityPointStructuresPlugin())
{
ImportInfo info = GetImportInfo(plugin);
// Call
IFileImporter fileImporter = info.CreateFileImporter(context, "test");
// Assert
Assert.IsInstanceOf <StabilityPointStructuresCalculationConfigurationImporter>(fileImporter);
}
mocks.VerifyAll();
}
public void Run_InvalidMacroStabilityInwardsCalculation_LogValidationStartAndEndWithErrors()
{
// Setup
MacroStabilityInwardsCalculationScenario invalidMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithInvalidInput();
var activity = new MacroStabilityInwardsCalculationActivity(invalidMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
{
Tuple <string, Level, Exception>[] tupleArray = messages.ToArray();
string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
Assert.AreEqual(6, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{invalidMacroStabilityInwardsCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual(Level.Error, tupleArray[2].Item2);
Assert.AreEqual(Level.Error, tupleArray[3].Item2);
Assert.AreEqual(Level.Error, tupleArray[4].Item2);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[5]);
});
Assert.AreEqual(ActivityState.Failed, activity.State);
}
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 Run_ValidMacroStabilityInwardsCalculation_PerformMacroStabilityInwardsValidationAndCalculationAndLogStartAndEnd()
{
// Setup
MacroStabilityInwardsCalculationScenario validMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
var activity = new MacroStabilityInwardsCalculationActivity(validMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
// Call
Action call = () => activity.Run();
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(7, msgs.Length);
Assert.AreEqual($"Uitvoeren van berekening '{validMacroStabilityInwardsCalculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
Assert.AreEqual("Validatie van waterspanningen in extreme omstandigheden is gestart.", msgs[2]);
Assert.AreEqual("Validatie van waterspanningen in dagelijkse omstandigheden is gestart.", msgs[3]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[4]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[6]);
});
Assert.AreEqual(ActivityState.Executed, activity.State);
Assert.IsNotNull(validMacroStabilityInwardsCalculation.Output);
}
}
public void Finish_ValidMacroStabilityInwardsCalculationAndRan_NotifyObserversOfMacroStabilityInwardsCalculation()
{
// Setup
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
MacroStabilityInwardsCalculationScenario validMacroStabilityInwardsCalculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
validMacroStabilityInwardsCalculation.Output = null;
validMacroStabilityInwardsCalculation.Attach(observer);
var activity = new MacroStabilityInwardsCalculationActivity(validMacroStabilityInwardsCalculation,
new GeneralMacroStabilityInwardsInput(),
AssessmentSectionTestHelper.GetTestAssessmentLevel());
activity.Run();
// Call
activity.Finish();
// Assert
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var calculation = new SemiProbabilisticPipingCalculationScenario();
FailureMechanismSection failureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
// Call
var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection);
// Assert
Assert.IsInstanceOf <PipingScenarioRow <SemiProbabilisticPipingCalculationScenario> >(row);
Assert.AreSame(calculation, row.CalculationScenario);
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityUplift));
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilityHeave));
TestHelper.AssertTypeConverter <SemiProbabilisticPipingScenarioRow, NoProbabilityValueDoubleConverter>(
nameof(SemiProbabilisticPipingScenarioRow.FailureProbabilitySellmeijer));
}
public void Constructor_CalculationWithOutput_ExpectedValues(double sectionLength)
{
// Setup
var failureMechanism = new PipingFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism, mocks);
mocks.ReplayAll();
var calculation = new SemiProbabilisticPipingCalculationScenario
{
Output = PipingTestDataGenerator.GetRandomSemiProbabilisticPipingOutput()
};
var failureMechanismSection = new FailureMechanismSection("test", new[]
{
new Point2D(0, 0),
new Point2D(sectionLength, 0)
});
// Call
var row = new SemiProbabilisticPipingScenarioRow(calculation, failureMechanism, failureMechanismSection, assessmentSection);
// Assert
DerivedSemiProbabilisticPipingOutput expectedDerivedOutput = DerivedSemiProbabilisticPipingOutputFactory.Create(calculation.Output, assessmentSection.FailureMechanismContribution.NormativeProbability);
Assert.AreEqual(expectedDerivedOutput.PipingProbability, row.FailureProbability);
Assert.AreEqual(expectedDerivedOutput.UpliftProbability, row.FailureProbabilityUplift);
Assert.AreEqual(expectedDerivedOutput.HeaveProbability, row.FailureProbabilityHeave);
Assert.AreEqual(expectedDerivedOutput.SellmeijerProbability, row.FailureProbabilitySellmeijer);
Assert.AreEqual(Math.Min(1.0, expectedDerivedOutput.PipingProbability * failureMechanism.PipingProbabilityAssessmentInput.GetN(
failureMechanismSection.Length)),
row.SectionFailureProbability);
mocks.VerifyAll();
}
public void Validate_ValidCalculationValidHydraulicBoundaryDatabaseNoSettings_LogsErrorAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new TestCalculatableFailureMechanism(),
mocks,
Path.Combine(testDataPath, "HRD nosettings.sqlite"));
mocks.ReplayAll();
var calculation = new TestStructuresCalculation();
var isValid = false;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
StringAssert.StartsWith("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt. " +
"Fout bij het lezen van bestand", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void Validate_WithoutImportedHydraulicBoundaryDatabase_LogsErrorAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(new TestCalculatableFailureMechanism(),
mocks);
mocks.ReplayAll();
var isValid = false;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(new TestStructuresCalculation(), assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("Er is geen hydraulische belastingendatabase geïmporteerd.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void Validate_ValidCalculationInvalidPreprocessorDirectory_LogsErrorAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(
new TestCalculatableFailureMechanism(), mocks, validHydraulicBoundaryDatabaseFilePath);
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.CanUsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor = true;
assessmentSection.HydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory = "NonExistingPreprocessorDirectory";
mocks.ReplayAll();
var calculation = new TestStructuresCalculation();
var isValid = true;
// Call
void Call() => isValid = TestStructuresCalculationService.Validate(calculation, assessmentSection);
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
Assert.AreEqual("De bestandsmap waar de preprocessor bestanden opslaat is ongeldig. De bestandsmap bestaat niet.", msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
});
Assert.IsFalse(isValid);
mocks.VerifyAll();
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsGrassCoverErosionInwardsCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
GrassCoverErosionInwardsCalculation calculation1 = CreateValidCalculation();
GrassCoverErosionInwardsCalculation calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionInwardsCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertGrassCoverErosionInwardsCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertGrassCoverErosionInwardsCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemCalculateAllDisabledAndTooltipSet()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocks, "invalidFilePath");
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(new DuneLocationCalculationsForTargetProbability(0.1),
new DuneErosionFailureMechanism(),
assessmentSection);
var builder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(builder);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip menu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = menu.Items[contextMenuCalculateAllIndex];
Assert.AreEqual("Alles be&rekenen", contextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.CalculateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
public void Export_NestedCalculationGroupWithGroupsWithCalculationsWithAndWithoutOutput_FolderNotExportedAndReturnsTrue()
{
// Setup
string folderPath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationGroupExporterTest)}.{nameof(Export_NestedCalculationGroupWithGroupsWithCalculationsWithAndWithoutOutput_FolderNotExportedAndReturnsTrue)}");
Directory.CreateDirectory(folderPath);
string filePath = Path.Combine(folderPath, "export.zip");
MacroStabilityInwardsCalculationScenario calculation1 = CreateCalculation("calculation1", false);
MacroStabilityInwardsCalculationScenario calculation2 = CreateCalculation("calculation2");
var rootGroup = new CalculationGroup
{
Name = "root"
};
var nestedGroup1 = new CalculationGroup
{
Name = "group1"
};
var nestedGroup2 = new CalculationGroup
{
Name = "group2"
};
nestedGroup2.Children.Add(calculation2);
nestedGroup2.Children.Add(calculation1);
nestedGroup1.Children.Add(nestedGroup2);
rootGroup.Children.Add(nestedGroup1);
var exporter = new MacroStabilityInwardsCalculationGroupExporter(rootGroup, new GeneralMacroStabilityInwardsInput(),
new PersistenceFactory(), filePath, fileExtension,
c => AssessmentSectionTestHelper.GetTestAssessmentLevel());
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
var exportResult = false;
void Call() => exportResult = exporter.Export();
// Assert
TestHelper.AssertLogMessagesWithLevelAreGenerated(Call, new[]
{
new Tuple <string, LogLevelConstant>($"Berekening '{calculation1.Name}' heeft geen uitvoer. Deze berekening wordt overgeslagen.", LogLevelConstant.Warn)
});
Assert.IsTrue(exportResult);
AssertFilesExistInZip(new[]
{
$"{nestedGroup1.Name}/{nestedGroup2.Name}/{calculation2.Name}.{fileExtension}"
}, filePath);
}
}
finally
{
DirectoryHelper.TryDelete(folderPath);
}
}
public void Export_CalculationGroupWithNestedGroupsAndCalculations_WritesFilesAndReturnsTrue()
{
// Setup
string folderPath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationGroupExporterTest)}.{nameof(Export_CalculationGroupWithNestedGroupsAndCalculations_WritesFilesAndReturnsTrue)}");
Directory.CreateDirectory(folderPath);
string filePath = Path.Combine(folderPath, "export.zip");
MacroStabilityInwardsCalculationScenario calculation1 = CreateCalculation("calculation1");
MacroStabilityInwardsCalculationScenario calculation2 = CreateCalculation("calculation2");
MacroStabilityInwardsCalculationScenario calculation3 = CreateCalculation("calculation3");
MacroStabilityInwardsCalculationScenario calculation4 = CreateCalculation("calculation4");
var rootCalculationGroup = new CalculationGroup();
var nestedGroup1 = new CalculationGroup
{
Name = "NestedGroup1"
};
var nestedGroup2 = new CalculationGroup
{
Name = "NestedGroup2"
};
nestedGroup2.Children.Add(calculation4);
nestedGroup1.Children.Add(calculation3);
nestedGroup1.Children.Add(nestedGroup2);
rootCalculationGroup.Children.Add(calculation1);
rootCalculationGroup.Children.Add(calculation2);
rootCalculationGroup.Children.Add(nestedGroup1);
var exporter = new MacroStabilityInwardsCalculationGroupExporter(rootCalculationGroup, new GeneralMacroStabilityInwardsInput(),
new PersistenceFactory(), filePath, fileExtension,
c => AssessmentSectionTestHelper.GetTestAssessmentLevel());
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
bool exportResult = exporter.Export();
// Assert
Assert.IsTrue(exportResult);
AssertFilesExistInZip(new[]
{
$"{calculation1.Name}.{fileExtension}",
$"{calculation2.Name}.{fileExtension}",
$"{nestedGroup1.Name}/{calculation3.Name}.{fileExtension}",
$"{nestedGroup1.Name}/{nestedGroup2.Name}/{calculation4.Name}.{fileExtension}"
}, filePath);
}
}
finally
{
DirectoryHelper.TryDelete(folderPath);
}
}
public void Validate_ValidInput_ReturnsEmpty()
{
// Call
string[] messages = MacroStabilityInwardsInputValidator.Validate(input,
AssessmentSectionTestHelper.GetTestAssessmentLevel()).ToArray();
// Assert
CollectionAssert.IsEmpty(messages);
}
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();
}