public void ContextMenuStrip_ClickOnAddTargetProbabilityItem_CalculationsForTargetProbabilityAddedAndObserversNotified()
{
// Given
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
Locations =
{
new TestHydraulicBoundaryLocation("Location 1"),
new TestHydraulicBoundaryLocation("Location 2")
}
}
};
var calculations = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>();
var context = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(calculations, assessmentSection);
var mockRepository = new MockRepository();
var calculationsObserver = mockRepository.StrictMock <IObserver>();
calculationsObserver.Expect(o => o.UpdateObserver());
calculations.Attach(calculationsObserver);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mockRepository);
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.ProjectStore).Return(mockRepository.Stub <IStoreProject>());
gui.Stub(g => g.DocumentViewController).Return(mockRepository.Stub <IDocumentViewController>());
mockRepository.ReplayAll();
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
{
// When
contextMenuAdapter.Items[contextMenuAddTargetProbabilityIndex].PerformClick();
// Then
Assert.AreEqual(1, calculations.Count);
Assert.AreEqual(0.01, calculations[0].TargetProbability);
Assert.AreEqual(2, calculations[0].HydraulicBoundaryLocationCalculations.Count);
}
}
}
mockRepository.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var failureMechanism = new StabilityStoneCoverFailureMechanism();
IAssessmentSection assessmentSection = CreateAssessmentSectionWithHydraulicBoundaryOutput();
HydraulicBoundaryLocation hydraulicBoundaryLocation = assessmentSection.HydraulicBoundaryDatabase.Locations.First();
StabilityStoneCoverWaveConditionsCalculation calculationA = GetValidCalculation(hydraulicBoundaryLocation);
StabilityStoneCoverWaveConditionsCalculation calculationB = GetValidCalculation(hydraulicBoundaryLocation);
List <ICalculationBase> calculations = failureMechanism.CalculationsGroup.Children;
calculations.AddRange(new[]
{
calculationA,
calculationB
});
var nodeData = new StabilityStoneCoverFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mainWindow);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestWaveConditionsCosineCalculator())
.Repeat
.Times(12);
mocks.ReplayAll();
plugin.Gui = gui;
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// When
contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
Assert.AreEqual(3, calculationA.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationA.Output.ColumnsOutput.Count());
Assert.AreEqual(3, calculationB.Output.BlocksOutput.Count());
Assert.AreEqual(3, calculationB.Output.ColumnsOutput.Count());
}
}
}
public void ContextMenuStrip_ClickOnAddTargetProbabilityItem_CalculationsForTargetProbabilityAddedAndObserversNotified()
{
// Given
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.SetDuneLocations(new[]
{
new TestDuneLocation("Location 1"),
new TestDuneLocation("Location 2")
});
var calculations = new ObservableList <DuneLocationCalculationsForTargetProbability>();
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(calculations,
failureMechanism,
new AssessmentSectionStub());
var mockRepository = new MockRepository();
var calculationsObserver = mockRepository.StrictMock <IObserver>();
calculationsObserver.Expect(o => o.UpdateObserver());
calculations.Attach(calculationsObserver);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mockRepository);
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
mockRepository.ReplayAll();
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
{
// When
contextMenuAdapter.Items[contextMenuAddTargetProbabilityIndex].PerformClick();
// Then
Assert.AreEqual(1, calculations.Count);
Assert.AreEqual(0.01, calculations[0].TargetProbability);
Assert.AreEqual(2, calculations[0].DuneLocationCalculations.Count);
}
}
}
mockRepository.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("Test");
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.ElementAt(0).Output =
new TestHydraulicBoundaryLocationCalculationOutput(2.0);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.Add(calculation);
var context = new GrassCoverErosionOutwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.ProjectOpened += null).IgnoreArguments();
gui.Stub(g => g.ProjectOpened -= null).IgnoreArguments();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var waveConditionsCalculator = new TestWaveConditionsCosineCalculator
{
Converged = false
};
HydraulicBoundaryCalculationSettings expectedCalculationSettings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedCalculationSettings,
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(waveConditionsCalculator)
.Repeat
.Times(6);
mocks.ReplayAll();
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(28, msgs.Length);
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gestart.", msgs.ElementAt(0));
CalculationServiceTestHelper.AssertValidationStartMessage(msgs.ElementAt(1));
CalculationServiceTestHelper.AssertValidationEndMessage(msgs.ElementAt(2));
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs.ElementAt(3));
IEnumerable <RoundedDouble> waterLevels = calculation.InputParameters.GetWaterLevels(
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result);
Assert.AreEqual(3, waterLevels.Count());
AssertWaveConditionsCalculationMessages(msgs, waterLevels, "golfoploop", 4);
AssertWaveConditionsCalculationMessages(msgs, waterLevels, "golfklap", 15);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs.ElementAt(26));
Assert.AreEqual($"Golfcondities berekenen voor '{calculation.Name}' is gelukt.", msgs.ElementAt(27));
});
}
}
}
public void PerformDuneLocationCalculationsFromContextMenu_HydraulicBoundaryDatabaseWithUsePreprocessorFalse_SendsRightInputToCalculationService()
{
// Setup
var duneLocationCalculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.01)
{
DuneLocationCalculations =
{
new DuneLocationCalculation(new DuneLocation(1300001, "A", new Point2D(0, 0), new DuneLocation.ConstructionProperties
{
CoastalAreaId = 0,
Offset = 0,
Orientation = 0,
D50 = 0.000007
}))
}
};
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(duneLocationCalculationsForTargetProbability);
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath,
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = false,
PreprocessorDirectory = "InvalidPreprocessorDirectory"
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
assessmentSection.Stub(a => a.Id).Return("13-1");
assessmentSection.Stub(a => a.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(duneLocationCalculationsForTargetProbability,
failureMechanism,
assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
var dunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator();
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(dunesBoundaryConditionsCalculator);
mocks.ReplayAll();
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
DunesBoundaryConditionsCalculationInput dunesBoundaryConditionsCalculationInput = dunesBoundaryConditionsCalculator.ReceivedInputs.First();
Assert.AreEqual(duneLocationCalculationsForTargetProbability.DuneLocationCalculations[0].DuneLocation.Id,
dunesBoundaryConditionsCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(duneLocationCalculationsForTargetProbability.TargetProbability),
dunesBoundaryConditionsCalculationInput.Beta);
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllCalculationsAndNotifyObservers()
{
// Setup
const string locationName1 = "1";
const string locationName2 = "2";
using (var treeViewControl = new TreeViewControl())
{
var duneLocationCalculationsForTargetProbability = new DuneLocationCalculationsForTargetProbability(0.01)
{
DuneLocationCalculations =
{
new DuneLocationCalculation(new DuneLocation(1300001, locationName1, new Point2D(0, 0), new DuneLocation.ConstructionProperties
{
CoastalAreaId = 0,
Offset = 0,
Orientation = 0,
D50 = 0.000007
})),
new DuneLocationCalculation(new DuneLocation(1300002, locationName2, new Point2D(0, 0), new DuneLocation.ConstructionProperties
{
CoastalAreaId = 0,
Offset = 0,
Orientation = 0,
D50 = 0.000007
}))
}
};
var failureMechanism = new DuneErosionFailureMechanism();
failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities.Add(duneLocationCalculationsForTargetProbability);
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
assessmentSection.Stub(a => a.Id).Return("13-1");
assessmentSection.Stub(a => a.GetFailureMechanisms()).Return(new[]
{
failureMechanism
});
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
var context = new DuneLocationCalculationsForUserDefinedTargetProbabilityContext(duneLocationCalculationsForTargetProbability,
failureMechanism,
assessmentSection);
var builder = new CustomItemsOnlyContextMenuBuilder();
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(builder);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
var calculationObserver = mocks.StrictMock <IObserver>();
calculationObserver.Expect(o => o.UpdateObserver()).Repeat.Times(2);
var calculationsObserver = mocks.StrictMock <IObserver>();
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(null))
.IgnoreArguments()
.Return(new TestDunesBoundaryConditionsCalculator())
.Repeat
.Times(2);
mocks.ReplayAll();
duneLocationCalculationsForTargetProbability.DuneLocationCalculations.Attach(calculationsObserver);
duneLocationCalculationsForTargetProbability.DuneLocationCalculations.ForEachElementDo(location => location.Attach(calculationObserver));
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
TestHelper.AssertLogMessages(() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(), messages =>
{
List <string> messageList = messages.ToList();
// Assert
Assert.AreEqual(16, messageList.Count);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName1}' (1/100) is gestart.", messageList[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[3]);
Assert.AreEqual($"Hydraulische belastingenberekening voor locatie '{locationName1}' (1/100) is niet geconvergeerd.", messageList[4]);
StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", messageList[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[6]);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName1}' (1/100) is gelukt.", messageList[7]);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName2}' (1/100) is gestart.", messageList[8]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[9]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[10]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[11]);
Assert.AreEqual($"Hydraulische belastingenberekening voor locatie '{locationName2}' (1/100) is niet geconvergeerd.", messageList[12]);
StringAssert.StartsWith("Hydraulische belastingenberekening is uitgevoerd op de tijdelijke locatie", messageList[13]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[14]);
Assert.AreEqual($"Hydraulische belastingen berekenen voor locatie '{locationName2}' (1/100) is gelukt.", messageList[15]);
});
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocksRepository);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation
{
Name = "A",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
DikeProfile = DikeProfileTestFactory.CreateDikeProfile()
}
});
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation
{
Name = "B",
InputParameters =
{
HydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(),
DikeProfile = DikeProfileTestFactory.CreateDikeProfile()
}
});
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = Path.Combine(testDataPath, "complete.sqlite")
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var assessmentSection = mocksRepository.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.Id).Return(string.Empty);
assessmentSection.Stub(a => a.FailureMechanismContribution)
.Return(FailureMechanismContributionTestFactory.CreateFailureMechanismContribution());
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(hydraulicBoundaryDatabase);
var context = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
int nrOfCalculators = failureMechanism.Calculations.Count();
var calculatorFactory = mocksRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(new TestOvertoppingCalculator())
.Repeat
.Times(nrOfCalculators);
mocksRepository.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
TestHelper.AssertLogMessages(() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick(), messages =>
{
List <string> messageList = messages.ToList();
// Assert
Assert.AreEqual(14, messageList.Count);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", messageList[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[3]);
StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", messageList[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[5]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", messageList[6]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", messageList[7]);
CalculationServiceTestHelper.AssertValidationStartMessage(messageList[8]);
CalculationServiceTestHelper.AssertValidationEndMessage(messageList[9]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messageList[10]);
StringAssert.StartsWith("De overloop en overslag berekening is uitgevoerd op de tijdelijke locatie", messageList[11]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messageList[12]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", messageList[13]);
});
}
}
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenLogMessagesAddedOutputSet()
{
// Given
var mockRepository = new MockRepository();
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = Path.Combine(testDataPath, "HRD ijsselmeer.sqlite")
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var context = new WaveHeightCalculationsForUserDefinedTargetProbabilitiesGroupContext(
assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities,
assessmentSection);
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mockRepository);
IGui gui = StubFactory.CreateGuiStub(mockRepository);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.ProjectStore).Return(mockRepository.Stub <IStoreProject>());
gui.Stub(g => g.DocumentViewController).Return(mockRepository.Stub <IDocumentViewController>());
var waveHeightCalculator = new TestWaveHeightCalculator
{
Converged = false
};
var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(waveHeightCalculator)
.Repeat
.Times(2);
mockRepository.ReplayAll();
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (var plugin = new RiskeerPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuRunWaveHeightCalculationsIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
const string calculationTypeDisplayName = "Golfhoogte";
const string calculationDisplayName = "Golfhoogte berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/4.000", msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/40.000", msgs, 8);
});
AssertHydraulicBoundaryLocationCalculationOutput(waveHeightCalculator, assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[0].HydraulicBoundaryLocationCalculations[0].Output);
AssertHydraulicBoundaryLocationCalculationOutput(waveHeightCalculator, assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities[1].HydraulicBoundaryLocationCalculations[0].Output);
}
}
}
mockRepository.VerifyAll();
}
public void GivenValidCalculation_WhenCalculatingFromContextMenu_ThenCalculationNotifiesObservers()
{
// Given
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
var calculationContext = new MacroStabilityInwardsCalculationScenarioContext(calculation,
new CalculationGroup(),
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
failureMechanism,
assessmentSection);
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.Get(calculationContext, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
plugin.Gui = gui;
calculation.Attach(observer);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(calculationContext, null, treeViewControl))
{
// When
void Action() => contextMenuAdapter.Items[contextMenuCalculateIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Action, messages =>
{
using (IEnumerator <string> msgs = messages.GetEnumerator())
{
Assert.IsTrue(msgs.MoveNext());
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs.Current);
Assert.IsTrue(msgs.MoveNext());
CalculationServiceTestHelper.AssertValidationStartMessage(msgs.Current);
Assert.IsTrue(msgs.MoveNext());
Assert.AreEqual("Validatie van waterspanningen in extreme omstandigheden is gestart.", msgs.Current);
Assert.IsTrue(msgs.MoveNext());
Assert.AreEqual("Validatie van waterspanningen in dagelijkse omstandigheden is gestart.", msgs.Current);
Assert.IsTrue(msgs.MoveNext());
CalculationServiceTestHelper.AssertValidationEndMessage(msgs.Current);
Assert.IsTrue(msgs.MoveNext());
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs.Current);
Assert.IsTrue(msgs.MoveNext());
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs.Current);
Assert.IsTrue(msgs.MoveNext());
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gelukt.", msgs.Current);
}
});
Assert.IsNotNull(calculation.Output);
}
}
}
public void GivenInvalidCalculation_WhenCalculatingFromContextMenu_ThenCalculationNotifiesObserversAndLogMessageAdded()
{
// Given
using (var treeViewControl = new TreeViewControl())
{
var calculation = new MacroStabilityInwardsCalculationScenario();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
var calculationContext = new MacroStabilityInwardsCalculationScenarioContext(calculation,
new CalculationGroup(),
Enumerable.Empty <MacroStabilityInwardsSurfaceLine>(),
Enumerable.Empty <MacroStabilityInwardsStochasticSoilModel>(),
failureMechanism,
assessmentSection);
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(calculationContext, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
plugin.Gui = gui;
calculation.Attach(observer);
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenuStrip = info.ContextMenuStrip(calculationContext, null, treeViewControl))
{
// When
void Action() => contextMenuStrip.Items[contextMenuCalculateIndex].PerformClick();
// Then
const int expectedValidationMessageCount = 3;
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(Action, messages =>
{
Tuple <string, Level, Exception>[] tupleArray = messages.ToArray();
string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
for (var i = 0; i < expectedValidationMessageCount; i++)
{
Assert.AreEqual(Level.Error, tupleArray[2 + i].Item2);
}
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[5]);
Assert.AreEqual($"Uitvoeren van berekening '{calculation.Name}' is mislukt.", msgs[6]);
});
Assert.IsNull(calculation.Output);
}
}
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
new DuneLocationCalculationsForTargetProbability(0.1),
new DuneLocationCalculationsForTargetProbability(0.01)
}
};
var duneLocation = new TestDuneLocation("Test");
failureMechanism.SetDuneLocations(new[]
{
duneLocation
});
var groupContext = new DuneLocationCalculationsForUserDefinedTargetProbabilitiesGroupContext(failureMechanism.DuneLocationCalculationsForUserDefinedTargetProbabilities,
failureMechanism,
assessmentSection);
var mocks = new MockRepository();
using (var treeViewControl = new TreeViewControl())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(groupContext, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
gui.Stub(g => g.ViewHost).Return(mocks.Stub <IViewHost>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var dunesBoundaryConditionsCalculator = new TestDunesBoundaryConditionsCalculator
{
Converged = false
};
calculatorFactory.Expect(cf => cf.CreateDunesBoundaryConditionsCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(dunesBoundaryConditionsCalculator).Repeat.Times(2);
mocks.ReplayAll();
using (var plugin = new DuneErosionPlugin())
{
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(groupContext, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
const string calculationTypeDisplayName = "Hydraulische belastingen";
const string calculationDisplayName = "Hydraulische belastingenberekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
duneLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/10", msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
duneLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/100", msgs, 8);
});
}
}
}
mocks.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenAllCalculationsScheduled()
{
// Given
string validFilePath = Path.Combine(testDataPath, "HRD dutch coast south.sqlite");
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike)
{
HydraulicBoundaryDatabase =
{
FilePath = validFilePath
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
SetHydraulicBoundaryLocationCalculationsForUserDefinedTargetProbabilities(assessmentSection);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var context = new HydraulicBoundaryDatabaseContext(assessmentSection.HydraulicBoundaryDatabase, assessmentSection);
using (var treeViewControl = new TreeViewControl())
using (var plugin = new RiskeerPlugin())
{
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
IGui gui = StubFactory.CreateGuiStub(mocks);
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(new CustomItemsOnlyContextMenuBuilder());
gui.Stub(g => g.DocumentViewController).Return(mocks.Stub <IDocumentViewController>());
gui.Stub(g => g.ViewCommands).Return(mocks.Stub <IViewCommands>());
gui.Stub(g => g.ProjectStore).Return(mocks.Stub <IStoreProject>());
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
var designWaterLevelCalculator = new TestDesignWaterLevelCalculator
{
Converged = false
};
var waveHeightCalculator = new TestWaveHeightCalculator
{
Converged = false
};
HydraulicBoundaryCalculationSettings expectedSettings = HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase);
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(designWaterLevelCalculator)
.Repeat
.Times(4);
calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
expectedSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
}).Return(waveHeightCalculator)
.Repeat
.Times(2);
mocks.ReplayAll();
TreeNodeInfo info = GetInfo(plugin);
plugin.Gui = gui;
plugin.Activate();
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (ContextMenuStrip contextMenuAdapter = info.ContextMenuStrip(context, null, treeViewControl))
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// When
void Call() => contextMenuAdapter.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(48, msgs.Length);
const string designWaterLevelCalculationTypeDisplayName = "Waterstand";
const string designWaterLevelCalculationDisplayName = "Waterstand berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/30.000",
msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/30.000 (1)",
msgs, 8);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/10",
msgs, 16);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, designWaterLevelCalculationTypeDisplayName, designWaterLevelCalculationDisplayName,
"1/100",
msgs, 24);
const string waveHeightCalculationTypeDisplayName = "Golfhoogte";
const string waveHeightCalculationDisplayName = "Golfhoogte berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, waveHeightCalculationTypeDisplayName, waveHeightCalculationDisplayName,
"1/40",
msgs, 32);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, waveHeightCalculationTypeDisplayName, waveHeightCalculationDisplayName,
"1/400",
msgs, 40);
});
}
}
mocks.VerifyAll();
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationB =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationC =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationD =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
calculationA.Name = "A";
calculationB.Name = "B";
calculationC.Name = "C";
calculationD.Name = "D";
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationC);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
failureMechanism.CalculationsGroup.Children.Add(calculationD);
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Stub(cf => cf.CreatePipingCalculator(null))
.IgnoreArguments()
.Return(new TestPipingCalculator());
mocks.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (new PipingSubCalculatorFactoryConfig())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(28, msgs.Length);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", msgs[5]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gestart.", msgs[6]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[7]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[9]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[12]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gelukt.", msgs[13]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", msgs[14]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[15]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[16]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[17]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[18]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", msgs[19]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gestart.", msgs[20]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[21]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[22]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[23]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[26]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gelukt.", msgs[27]);
});
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
MacroStabilityInwardsCalculationScenario calculationA = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
calculationA.Name = "A";
MacroStabilityInwardsCalculationScenario calculationB = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(hydraulicBoundaryLocation);
calculationB.Name = "B";
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
var context = new MacroStabilityInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (new MacroStabilityInwardsCalculatorFactoryConfig())
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
Assert.AreEqual("Uitvoeren van berekening 'A' 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("Uitvoeren van berekening 'A' is gelukt.", msgs[7]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", msgs[8]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[9]);
Assert.AreEqual("Validatie van waterspanningen in extreme omstandigheden is gestart.", msgs[10]);
Assert.AreEqual("Validatie van waterspanningen in dagelijkse omstandigheden is gestart.", msgs[11]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[12]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[13]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[14]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", msgs[15]);
});
}
}
}
