public void Calculate_CalculationRanErrorInSettingIllustrationPoints_IllustrationPointsNotSetAndLogsWarning()
{
// Setup
const string locationName = "locationName";
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsResult = GeneralResultTestFactory.CreateGeneralResultWithDuplicateStochasts(),
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName))
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = true
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
{
Tuple <string, Level, Exception>[] tupleArray = messages.ToArray();
string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual($"Fout bij het uitlezen van de illustratiepunten voor berekening {locationName}: " +
"Een of meerdere stochasten hebben dezelfde naam. " +
"Het uitlezen van illustratiepunten wordt overgeslagen.", msgs[1]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
});
Assert.IsNotNull(hydraulicBoundaryLocationCalculation.Output);
Assert.IsFalse(hydraulicBoundaryLocationCalculation.Output.HasGeneralResult);
}
mockRepository.VerifyAll();
}
private static void AssertDesignWaterLevelCalculationActivity(Activity activity,
HydraulicBoundaryLocation hydraulicBoundaryLocation,
string calculationIdentifier,
double targetProbability,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var calculator = new TestDesignWaterLevelCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
Action call = activity.Run;
string expectedLogMessage = $"Waterstand berekenen voor locatie '{hydraulicBoundaryLocation.Name}' ({calculationIdentifier}) is gestart.";
TestHelper.AssertLogMessageIsGenerated(call, expectedLogMessage);
AssessmentLevelCalculationInput designWaterLevelCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, designWaterLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), designWaterLevelCalculationInput.Beta);
}
mocks.VerifyAll();
}
public void Calculate_CancelCalculationWithValidInput_CancelsCalculator()
{
// Setup
var calculator = new TestDesignWaterLevelCalculator();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.Stub <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
var service = new DesignWaterLevelCalculationService();
calculator.CalculationFinishedHandler += (s, e) => service.Cancel();
// Call
service.Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
Assert.IsTrue(calculator.IsCanceled);
}
mockRepository.VerifyAll();
}
public void Calculate_ValidDesignWaterLevelCalculationButIllustrationPointResultsOfIncorrectType_IllustrationPointNotSetAndLog()
{
// Setup
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsResult = TestGeneralResult.CreateGeneralResultWithFaultTreeIllustrationPoints(),
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation())
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = true
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessagesWithLevelAndLoggedExceptions(call, messages =>
{
Tuple <string, Level, Exception>[] tupleArray = messages.ToArray();
string[] msgs = tupleArray.Select(tuple => tuple.Item1).ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual("Het uitlezen van illustratiepunten is mislukt.", msgs[1]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
Assert.IsInstanceOf <IllustrationPointConversionException>(tupleArray[1].Item3);
});
Assert.IsNotNull(hydraulicBoundaryLocationCalculation.Output);
Assert.IsFalse(hydraulicBoundaryLocationCalculation.Output.HasGeneralResult);
}
mockRepository.VerifyAll();
}
public void Calculate_ValidDesignWaterLevelCalculationAndConverges_SetsOutputAndLogs(bool readIllustrationPoints)
{
// Setup
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsResult = new TestGeneralResult(),
Converged = true
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation)
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = readIllustrationPoints
}
};
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
Assert.IsFalse(calculator.IsCanceled);
HydraulicBoundaryLocationCalculationOutput actualOutput = hydraulicBoundaryLocationCalculation.Output;
Assert.IsNotNull(actualOutput);
Assert.AreEqual(readIllustrationPoints, actualOutput.HasGeneralResult);
}
mockRepository.VerifyAll();
}
public void Calculate_ValidData_StartsCalculationWithRightParameters(bool usePreprocessor)
{
// Setup
const double targetProbability = 1.0 / 30;
string preprocessorDirectory = usePreprocessor
? validPreprocessorDirectory
: string.Empty;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true
};
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
var calculationMessageProvider = mockRepository.StrictMock <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
calculationSettings,
targetProbability,
calculationMessageProvider);
// Assert
AssessmentLevelCalculationInput expectedInput = CreateInput(hydraulicBoundaryLocation.Id, targetProbability);
AssessmentLevelCalculationInput actualInput = calculator.ReceivedInputs.Single();
AssertInput(expectedInput, actualInput);
Assert.IsFalse(calculator.IsCanceled);
Assert.AreEqual(usePreprocessor, actualInput.PreprocessorSetting.RunPreprocessor);
}
mockRepository.VerifyAll();
}
public void Run_ValidInput_PerformValidationAndCalculationAndLogStartAndEnd()
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
const double targetProbability = 0.01;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true
};
HydraulicBoundaryCalculationSettings calculationSettings = CreateCalculationSettings();
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(locationName);
var activity = new DesignWaterLevelCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
calculationSettings,
targetProbability,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, m =>
{
string[] messages = m.ToArray();
Assert.AreEqual(6, messages.Length);
Assert.AreEqual($"{GetActivityDescription(locationName, calculationIdentifier)} is gestart.", messages[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messages[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messages[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messages[3]);
StringAssert.StartsWith("Waterstand berekening is uitgevoerd op de tijdelijke locatie", messages[4]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messages[5]);
});
}
Assert.AreEqual(ActivityState.Executed, activity.State);
mockRepository.VerifyAll();
}
public void Run_CalculationResultingInNoConvergence_LogWarningNoConvergence()
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
var calculator = new TestDesignWaterLevelCalculator
{
Converged = false,
IllustrationPointsResult = new TestGeneralResult()
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName))
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = true
},
Output = new TestHydraulicBoundaryLocationCalculationOutput(double.NaN, CalculationConvergence.CalculatedConverged)
};
var activity = new DesignWaterLevelCalculationActivity(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
0.01,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(7, msgs.Length);
Assert.AreEqual($"Waterstand berekening voor locatie 'locationName' ({calculationIdentifier}) is niet geconvergeerd.", msgs[4]);
});
Assert.AreEqual(CalculationConvergence.CalculatedNotConverged, hydraulicBoundaryLocationCalculation.Output.CalculationConvergence);
}
mockRepository.VerifyAll();
}
public void Run_ValidInput_PerformCalculationWithCorrectInput(bool usePreprocessor)
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
const double targetProbability = 0.01;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true
};
string preprocessorDirectory = usePreprocessor ? validPreprocessorDirectory : string.Empty;
var calculationSettings = new HydraulicBoundaryCalculationSettings(validHydraulicBoundaryDatabaseFilePath,
validHlcdFilePath,
false,
preprocessorDirectory);
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
calculationSettings, (HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(calculator);
mockRepository.ReplayAll();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(locationName);
var activity = new DesignWaterLevelCalculationActivity(new HydraulicBoundaryLocationCalculation(hydraulicBoundaryLocation),
calculationSettings,
targetProbability,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
// Assert
AssessmentLevelCalculationInput designWaterLevelCalculationInput = calculator.ReceivedInputs.Single();
Assert.AreEqual(hydraulicBoundaryLocation.Id, designWaterLevelCalculationInput.HydraulicBoundaryLocationId);
Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(targetProbability), designWaterLevelCalculationInput.Beta);
}
Assert.AreEqual(ActivityState.Executed, activity.State);
mockRepository.VerifyAll();
}
public void Calculate_ValidDesignWaterLevelCalculationCalculateIllustrationPointsFalseAndIllustrationPointsParserErrorMessageNotNull_DoesNotLog()
{
// Setup
var mockRepository = new MockRepository();
var calculator = new TestDesignWaterLevelCalculator
{
IllustrationPointsParserErrorMessage = "Some Error Message",
Converged = true
};
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.Stub <ICalculationMessageProvider>();
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation());
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
Action call = () => new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(3, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[1]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[2]);
});
}
mockRepository.VerifyAll();
}
public void Run_ValidCalculation_SetsDesignWaterLevelAndConvergence(HydraulicBoundaryLocationCalculation hydraulicBoundaryLocationCalculation)
{
// Setup
const double targetProbability = 0.01;
const double expectedDesignWaterLevel = 3.5;
var calculator = new TestDesignWaterLevelCalculator
{
Converged = true,
DesignWaterLevel = expectedDesignWaterLevel
};
if (hydraulicBoundaryLocationCalculation.InputParameters.ShouldIllustrationPointsBeCalculated)
{
calculator.IllustrationPointsResult = new TestGeneralResult();
}
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var activity = new DesignWaterLevelCalculationActivity(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
targetProbability,
"1/100");
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
activity.Run();
}
// Assert
HydraulicBoundaryLocationCalculationOutput calculationOutput = hydraulicBoundaryLocationCalculation.Output;
Assert.IsNotNull(calculationOutput);
Assert.AreEqual(expectedDesignWaterLevel, calculationOutput.Result, calculationOutput.Result.GetAccuracy());
Assert.AreEqual(CalculationConvergence.CalculatedConverged, calculationOutput.CalculationConvergence);
mockRepository.VerifyAll();
}
public void Run_InvalidCalculation_LogsErrorAndThrowException(bool endInFailure, string lastErrorFileContent)
{
// Setup
const string locationName = "locationName";
const string calculationFailedMessage = "calculationFailedMessage";
var calculator = new TestDesignWaterLevelCalculator
{
LastErrorFileContent = lastErrorFileContent,
EndInFailure = endInFailure
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
var calculationMessageProvider = mockRepository.Stub <ICalculationMessageProvider>();
if (endInFailure && string.IsNullOrEmpty(lastErrorFileContent))
{
calculationMessageProvider.Expect(mp => mp.GetCalculationFailedMessage(locationName)).Return(calculationFailedMessage);
}
else
{
calculationMessageProvider.Expect(mp => mp.GetCalculationFailedWithErrorReportMessage(locationName,
endInFailure && string.IsNullOrEmpty(lastErrorFileContent)
? calculator.HydraRingCalculationException.Message
: lastErrorFileContent
)).Return(calculationFailedMessage);
}
mockRepository.ReplayAll();
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName));
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
HydraRingCalculationException exception = null;
// Call
Action call = () =>
{
try
{
new DesignWaterLevelCalculationService().Calculate(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
1.0 / 30,
calculationMessageProvider);
}
catch (HydraRingCalculationException e)
{
exception = e;
}
};
// Assert
TestHelper.AssertLogMessages(call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(4, msgs.Length);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[0]);
Assert.AreEqual(calculationFailedMessage, msgs[1]);
Assert.AreEqual($"Waterstand berekening is uitgevoerd op de tijdelijke locatie '{calculator.OutputDirectory}'. " +
"Gedetailleerde invoer en uitvoer kan in de bestanden op deze locatie worden gevonden.", msgs[2]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[3]);
});
Assert.IsInstanceOf <HydraRingCalculationException>(exception);
}
mockRepository.VerifyAll();
}
public void Run_InvalidCalculation_LogsErrorOutputNotUpdatedAndActivityStateFailed(bool endInFailure, string lastErrorFileContent)
{
// Setup
const string locationName = "locationName";
const string calculationIdentifier = "1/100";
var calculator = new TestDesignWaterLevelCalculator
{
EndInFailure = endInFailure,
LastErrorFileContent = lastErrorFileContent
};
var mockRepository = new MockRepository();
var calculatorFactory = mockRepository.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(null))
.IgnoreArguments()
.Return(calculator);
mockRepository.ReplayAll();
var output = new TestHydraulicBoundaryLocationCalculationOutput(double.NaN, CalculationConvergence.CalculatedConverged);
var hydraulicBoundaryLocationCalculation = new HydraulicBoundaryLocationCalculation(new TestHydraulicBoundaryLocation(locationName))
{
InputParameters =
{
ShouldIllustrationPointsBeCalculated = true
},
Output = output
};
var activity = new DesignWaterLevelCalculationActivity(hydraulicBoundaryLocationCalculation,
CreateCalculationSettings(),
0.01,
calculationIdentifier);
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
// Call
void Call() => activity.Run();
// Assert
TestHelper.AssertLogMessages(Call, m =>
{
string[] messages = m.ToArray();
Assert.AreEqual(7, messages.Length);
Assert.AreEqual($"{GetActivityDescription(locationName, calculationIdentifier)} is gestart.", messages[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(messages[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(messages[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(messages[3]);
string expectedFailureMessage = string.IsNullOrEmpty(lastErrorFileContent)
? $"Er is een fout opgetreden tijdens de waterstand berekening voor locatie '{locationName}' ({calculationIdentifier}). Er is geen foutrapport beschikbaar."
: $"Er is een fout opgetreden tijdens de waterstand berekening voor locatie '{locationName}' ({calculationIdentifier}). Bekijk het foutrapport door op details te klikken.{Environment.NewLine}{lastErrorFileContent}";
Assert.AreEqual(expectedFailureMessage, messages[4]);
StringAssert.StartsWith("Waterstand berekening is uitgevoerd op de tijdelijke locatie", messages[5]);
CalculationServiceTestHelper.AssertCalculationEndMessage(messages[6]);
});
Assert.AreSame(output, hydraulicBoundaryLocationCalculation.Output);
Assert.AreEqual(CalculationConvergence.CalculatedConverged, hydraulicBoundaryLocationCalculation.Output.CalculationConvergence);
Assert.AreEqual(ActivityState.Failed, activity.State);
}
mockRepository.VerifyAll();
}
public void GivenValidCalculations_WhenCalculatingAllFromContextMenu_ThenLogMessagesAddedOutputSet()
{
// Given
const double signalFloodingProbability = 0.002;
const double maximumAllowableFloodingProbability = 0.005;
var mockRepository = new MockRepository();
var assessmentSection = new AssessmentSectionStub
{
HydraulicBoundaryDatabase =
{
FilePath = Path.Combine(testDataPath, "HRD ijsselmeer.sqlite")
},
FailureMechanismContribution =
{
MaximumAllowableFloodingProbability = maximumAllowableFloodingProbability,
SignalFloodingProbability = signalFloodingProbability
}
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
});
var context = new WaterLevelCalculationsForNormTargetProbabilitiesGroupContext(new ObservableList <HydraulicBoundaryLocation>(),
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 designWaterLevelCalculator = new TestDesignWaterLevelCalculator
{
Converged = false
};
var calculatorFactory = mockRepository.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(assessmentSection.HydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(designWaterLevelCalculator)
.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[contextMenuRunWaterLevelCalculationsIndex].PerformClick();
// Then
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(16, msgs.Length);
const string calculationTypeDisplayName = "Waterstand";
const string calculationDisplayName = "Waterstand berekening";
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/200", msgs, 0);
HydraulicBoundaryLocationCalculationActivityLogTestHelper.AssertHydraulicBoundaryLocationCalculationMessages(
hydraulicBoundaryLocation.Name, calculationTypeDisplayName, calculationDisplayName, "1/500", msgs, 8);
});
AssertHydraulicBoundaryLocationCalculationOutput(designWaterLevelCalculator, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output);
AssertHydraulicBoundaryLocationCalculationOutput(designWaterLevelCalculator, assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Single().Output);
}
}
}
mockRepository.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();
}
