public void Import_ValidFileWithScenarioInformation_UpdatesHydraulicBoundaryDatabaseWithImportedData()
{
// Setup
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportHydraulicBoundaryDatabase(assessmentSection, validHrdFilePath);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
string filePath = Path.Combine(testDataPath, "hlcdWithValidScenarioInformation.sqlite");
var mocks = new MockRepository();
var handler = mocks.StrictMock <IHydraulicLocationConfigurationDatabaseUpdateHandler>();
handler.Expect(h => h.InquireConfirmation()).Return(true);
handler.Expect(h => h.Update(Arg <HydraulicBoundaryDatabase> .Is.Same(hydraulicBoundaryDatabase),
Arg <ReadHydraulicLocationConfigurationDatabaseSettings> .Is.NotNull,
Arg <bool> .Is.Equal(false),
Arg <string> .Is.Equal(filePath)))
.Return(Enumerable.Empty <IObservable>());
mocks.ReplayAll();
var importer = new HydraulicLocationConfigurationDatabaseImporter(hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings, handler,
hydraulicBoundaryDatabase, filePath);
// Call
var importResult = false;
Action call = () => importResult = importer.Import();
// Assert
TestHelper.AssertLogMessageIsGenerated(call, $"Gegevens zijn geïmporteerd vanuit bestand '{filePath}'.", 1);
Assert.IsTrue(importResult);
mocks.VerifyAll();
}
public void Calculate_ValidPathEmptyCalculationList_NoLog()
{
// Setup
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = validFilePath
};
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(hydraulicBoundaryDatabase);
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase)
.Return(hydraulicBoundaryDatabase);
mocks.ReplayAll();
using (var viewParent = new TestViewParentForm())
{
var guiService = new DuneLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.Calculate(Enumerable.Empty <DuneLocationCalculation>(), assessmentSection, 0.01, "1/100");
// Assert
TestHelper.AssertLogMessagesCount(Call, 0);
}
mocks.VerifyAll();
}
public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsWaveImpactAsphaltCoverWaveConditionsCalculationActivitiesWithParametersSet()
{
// Setup
WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
var calculations = new CalculationGroup
{
Children =
{
calculation1,
calculation2
}
};
// Call
IEnumerable <CalculatableActivity> activities = WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
calculations, failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.First(), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
public void Update_ReadHydraulicLocationConfigurationDatabaseSettingsNull_SetsDefaultValuesAndLogsWarning()
{
// Setup
const string hlcdFilePath = "some/file/path";
var handler = new HydraulicLocationConfigurationDatabaseUpdateHandler(CreateAssessmentSection());
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
void Call() => handler.Update(hydraulicBoundaryDatabase, null, usePreprocessorClosure, hlcdFilePath);
// Assert
const string expectedMessage = "De tabel 'ScenarioInformation' in het HLCD bestand is niet aanwezig. Er worden standaardwaarden " +
"conform WBI2017 gebruikt voor de HLCD bestandsinformatie.";
TestHelper.AssertLogMessageWithLevelIsGenerated(Call, Tuple.Create(expectedMessage, LogLevelConstant.Warn), 1);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(hlcdFilePath, settings.FilePath);
Assert.AreEqual("WBI2017", settings.ScenarioName);
Assert.AreEqual(2023, settings.Year);
Assert.AreEqual("WBI2017", settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual("Conform WBI2017", settings.SeaLevel);
Assert.AreEqual("Conform WBI2017", settings.RiverDischarge);
Assert.AreEqual("Conform WBI2017", settings.LakeLevel);
Assert.AreEqual("Conform WBI2017", settings.WindDirection);
Assert.AreEqual("Conform WBI2017", settings.WindSpeed);
Assert.AreEqual("Gegenereerd door Riskeer (conform WBI2017)", settings.Comment);
}
/// <summary>
/// Reads the <see cref="HydraulicBoundaryDatabaseEntity"/> and uses the information to
/// update a <see cref="HydraulicBoundaryDatabase"/>.
/// </summary>
/// <param name="entity">The <see cref="HydraulicBoundaryDatabaseEntity"/> to update the
/// <see cref="HydraulicBoundaryDatabase"/>.</param>
/// <param name="hydraulicBoundaryDatabase">The <see cref="HydraulicBoundaryDatabase"/> to update.</param>
/// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
internal static void Read(this HydraulicBoundaryDatabaseEntity entity, HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (entity == null)
{
throw new ArgumentNullException(nameof(entity));
}
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
hydraulicBoundaryDatabase.FilePath = entity.FilePath;
hydraulicBoundaryDatabase.Version = entity.Version;
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.SetValues(
entity.HydraulicLocationConfigurationSettingsFilePath,
entity.HydraulicLocationConfigurationSettingsScenarioName,
entity.HydraulicLocationConfigurationSettingsYear,
entity.HydraulicLocationConfigurationSettingsScope,
Convert.ToBoolean(entity.HydraulicLocationConfigurationSettingsUsePreprocessorClosure),
entity.HydraulicLocationConfigurationSettingsSeaLevel,
entity.HydraulicLocationConfigurationSettingsRiverDischarge,
entity.HydraulicLocationConfigurationSettingsLakeLevel,
entity.HydraulicLocationConfigurationSettingsWindDirection,
entity.HydraulicLocationConfigurationSettingsWindSpeed,
entity.HydraulicLocationConfigurationSettingsComment);
}
private static string[] ValidateInput(HydraulicBoundaryDatabase hydraulicBoundaryDatabase,
WaveConditionsInput input,
RoundedDouble assessmentLevel)
{
var validationResults = new List <string>();
string databaseFilePathValidationProblem = HydraulicBoundaryDatabaseConnectionValidator.Validate(hydraulicBoundaryDatabase);
if (!string.IsNullOrEmpty(databaseFilePathValidationProblem))
{
validationResults.Add(databaseFilePathValidationProblem);
}
string preprocessorDirectoryValidationProblem = HydraulicBoundaryDatabaseHelper.ValidatePreprocessorDirectory(hydraulicBoundaryDatabase.EffectivePreprocessorDirectory());
if (!string.IsNullOrEmpty(preprocessorDirectoryValidationProblem))
{
validationResults.Add(preprocessorDirectoryValidationProblem);
}
if (validationResults.Any())
{
return(validationResults.ToArray());
}
validationResults.AddRange(ValidateWaveConditionsInput(input, assessmentLevel));
return(validationResults.ToArray());
}
public void DoPostImportUpdates_CancelingImport_DoNotNotifyObserversAndNotDoPostReplacementUpdates()
{
// Setup
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
var mocks = new MockRepository();
var observer = mocks.StrictMock <IObserver>();
var handler = mocks.StrictMock <IHydraulicBoundaryDatabaseUpdateHandler>();
var importer = new HydraulicBoundaryDatabaseImporter(hydraulicBoundaryDatabase, handler, validFilePath);
handler.Expect(h => h.IsConfirmationRequired(null, null)).IgnoreArguments()
.WhenCalled(invocation => importer.Cancel())
.Return(false);
mocks.ReplayAll();
hydraulicBoundaryDatabase.Attach(observer);
// Precondition
Assert.IsFalse(importer.Import());
// Call
importer.DoPostImport();
// Assert
mocks.VerifyAll(); // Expect no NotifyObserver calls
}
/// <summary>
/// Creates a <see cref="HydraulicBoundaryDatabaseEntity"/> based on the information of the
/// <see cref="HydraulicBoundaryDatabase"/>.
/// </summary>
/// <param name="hydraulicBoundaryDatabase">The <see cref="HydraulicBoundaryDatabase"/> to create a
/// <see cref="HydraulicBoundaryDatabaseEntity"/> for.</param>
/// <returns>A new <see cref="HydraulicBoundaryDatabaseEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryDatabase"/>
/// is <c>null</c>.</exception>
internal static HydraulicBoundaryDatabaseEntity Create(this HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
return(new HydraulicBoundaryDatabaseEntity
{
FilePath = hydraulicBoundaryDatabase.FilePath.DeepClone(),
Version = hydraulicBoundaryDatabase.Version.DeepClone(),
HydraulicLocationConfigurationSettingsFilePath = settings.FilePath.DeepClone(),
HydraulicLocationConfigurationSettingsUsePreprocessorClosure = Convert.ToByte(settings.UsePreprocessorClosure),
HydraulicLocationConfigurationSettingsScenarioName = settings.ScenarioName.DeepClone(),
HydraulicLocationConfigurationSettingsYear = settings.Year,
HydraulicLocationConfigurationSettingsScope = settings.Scope.DeepClone(),
HydraulicLocationConfigurationSettingsSeaLevel = settings.SeaLevel.DeepClone(),
HydraulicLocationConfigurationSettingsRiverDischarge = settings.RiverDischarge.DeepClone(),
HydraulicLocationConfigurationSettingsLakeLevel = settings.LakeLevel.DeepClone(),
HydraulicLocationConfigurationSettingsWindDirection = settings.WindDirection.DeepClone(),
HydraulicLocationConfigurationSettingsWindSpeed = settings.WindSpeed.DeepClone(),
HydraulicLocationConfigurationSettingsComment = settings.Comment.DeepClone()
});
}
public void GetProperties_WithHydraulicBoundaryDatabaseWithPreprocessorData_ReturnExpectedValues()
{
// Setup
const bool usePreprocessor = true;
const string preprocessorDirectory = @"C:\preprocessor";
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = usePreprocessor,
PreprocessorDirectory = preprocessorDirectory
}
};
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
Assert.AreEqual(usePreprocessor, properties.UsePreprocessor);
Assert.AreEqual(preprocessorDirectory, properties.PreprocessorDirectory);
Assert.AreEqual(preprocessorDirectory, properties.PreprocessorDirectoryReadOnly);
mocks.VerifyAll();
}
public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivityWithParametersSet()
{
// Setup
GrassCoverErosionOutwardsFailureMechanism failureMechanism = new GrassCoverErosionOutwardsFailureMechanism();
var assessmentSection = new AssessmentSectionStub();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
hydraulicBoundaryDatabase.FilePath = validFilePath;
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation);
// Call
CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveConditionsCalculationActivity(calculation,
failureMechanism,
assessmentSection);
// Assert
Assert.IsInstanceOf <GrassCoverErosionOutwardsWaveConditionsCalculationActivity>(activity);
AssertGrassCoverErosionOutwardsWaveConditionsCalculationActivity(
activity,
calculation,
assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result,
hydraulicBoundaryDatabase);
}
private static void AssertStabilityPointStructuresCalculationActivity(Activity activity,
ICalculation <StabilityPointStructuresInput> calculation,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestStructuresCalculator <StructuresStabilityPointCalculationInput>();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateStructuresCalculator <StructuresStabilityPointCalculationInput>(
Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
StructuresStabilityPointCalculationInput actualInput = testCalculator.ReceivedInputs.Single();
Assert.AreEqual(calculation.InputParameters.FailureProbabilityStructureWithErosion,
actualInput.Variables.Single(v => v.VariableId == 105).Value);
}
mocks.VerifyAll();
}
public AssessmentSectionStub(IEnumerable <IFailureMechanism> failureMechanisms)
{
this.failureMechanisms = failureMechanisms;
FailureMechanismContribution = new FailureMechanismContribution(1.0 / 30000,
1.0 / 30000);
BackgroundData = new BackgroundData(new WmtsBackgroundDataConfiguration())
{
Name = "Background data"
};
ReferenceLine = new ReferenceLine();
HydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
WaterLevelCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.0001),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.00001)
};
WaveHeightCalculationsForUserDefinedTargetProbabilities = new ObservableList <HydraulicBoundaryLocationCalculationsForTargetProbability>
{
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.00025),
new HydraulicBoundaryLocationCalculationsForTargetProbability(0.000025)
};
waterLevelCalculationsForSignalFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>();
waterLevelCalculationsForMaximumAllowableFloodingProbability = new ObservableList <HydraulicBoundaryLocationCalculation>();
SpecificFailureMechanisms = new ObservableList <SpecificFailureMechanism>();
}
public void CreateCalculationActivitiesForCalculations_WithValidDataAndUsePreprocessorStates_ReturnsExpectedActivities(bool usePreprocessor)
{
// Setup
const double targetProbability = 0.01;
const string calculationIdentifier = "1/100";
AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor);
var duneLocation1 = new DuneLocation(1, "locationName1", new Point2D(1, 1), new DuneLocation.ConstructionProperties());
var duneLocation2 = new DuneLocation(2, "locationName2", new Point2D(2, 2), new DuneLocation.ConstructionProperties());
// Call
CalculatableActivity[] activities = DuneLocationCalculationActivityFactory.CreateCalculationActivities(
new[]
{
new DuneLocationCalculation(duneLocation1),
new DuneLocationCalculation(duneLocation2)
},
assessmentSection,
targetProbability,
calculationIdentifier).ToArray();
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(DuneLocationCalculationActivity));
Assert.AreEqual(2, activities.Length);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertDuneLocationCalculationActivity(activities[0], calculationIdentifier, duneLocation1.Name, duneLocation1.Id, targetProbability, hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[1], calculationIdentifier, duneLocation2.Name, duneLocation2.Id, targetProbability, hydraulicBoundaryDatabase);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidDataAndUsePreprocessorStates_ReturnsExpectedActivities(bool usePreprocessor)
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor);
var duneLocationCalculationsForTargetProbability1 = new DuneLocationCalculationsForTargetProbability(0.1);
var duneLocationCalculationsForTargetProbability2 = new DuneLocationCalculationsForTargetProbability(0.01);
var failureMechanism = new DuneErosionFailureMechanism
{
DuneLocationCalculationsForUserDefinedTargetProbabilities =
{
duneLocationCalculationsForTargetProbability1,
duneLocationCalculationsForTargetProbability2
}
};
var duneLocation1 = new DuneLocation(1, "locationName1", new Point2D(1, 1), new DuneLocation.ConstructionProperties());
var duneLocation2 = new DuneLocation(2, "locationName2", new Point2D(2, 2), new DuneLocation.ConstructionProperties());
failureMechanism.SetDuneLocations(new[]
{
duneLocation1,
duneLocation2
});
// Call
CalculatableActivity[] activities = DuneLocationCalculationActivityFactory.CreateCalculationActivities(failureMechanism, assessmentSection).ToArray();
// Assert
Assert.AreEqual(4, activities.Length);
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertDuneLocationCalculationActivity(activities[0],
"1/10",
duneLocation1.Name,
duneLocation1.Id,
duneLocationCalculationsForTargetProbability1.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[1],
"1/10",
duneLocation2.Name,
duneLocation2.Id,
duneLocationCalculationsForTargetProbability1.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[2],
"1/100",
duneLocation1.Name,
duneLocation1.Id,
duneLocationCalculationsForTargetProbability2.TargetProbability,
hydraulicBoundaryDatabase);
AssertDuneLocationCalculationActivity(activities[3],
"1/100",
duneLocation2.Name,
duneLocation2.Id,
duneLocationCalculationsForTargetProbability2.TargetProbability,
hydraulicBoundaryDatabase);
}
private static void AssertGrassCoverErosionInwardsCalculationActivity(Activity activity,
GrassCoverErosionInwardsCalculation calculation,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
var mocks = new MockRepository();
var testCalculator = new TestOvertoppingCalculator();
var calculatorFactory = mocks.StrictMock <IHydraRingCalculatorFactory>();
calculatorFactory.Expect(cf => cf.CreateOvertoppingCalculator(Arg <HydraRingCalculationSettings> .Is.NotNull))
.WhenCalled(invocation =>
{
HydraRingCalculationSettingsTestHelper.AssertHydraRingCalculationSettings(
HydraulicBoundaryCalculationSettingsFactory.CreateSettings(hydraulicBoundaryDatabase),
(HydraRingCalculationSettings)invocation.Arguments[0]);
})
.Return(testCalculator);
mocks.ReplayAll();
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
{
activity.Run();
Assert.AreEqual(calculation.InputParameters.BreakWater.Height, testCalculator.ReceivedInputs.Single().BreakWater.Height);
}
mocks.VerifyAll();
}
public void GetProperties_WithUnlinkedDatabase_ReturnsExpectedValues()
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
// Precondition
Assert.IsFalse(hydraulicBoundaryDatabase.IsLinked());
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
Assert.IsEmpty(properties.HrdFilePath);
Assert.IsEmpty(properties.HlcdFilePath);
Assert.IsEmpty(properties.HlcdFilePathReadOnly);
Assert.IsFalse(properties.UsePreprocessorClosure);
Assert.IsEmpty(properties.ScenarioName);
Assert.IsEmpty(properties.Year);
Assert.IsEmpty(properties.Scope);
Assert.IsEmpty(properties.SeaLevel);
Assert.IsEmpty(properties.RiverDischarge);
Assert.IsEmpty(properties.LakeLevel);
Assert.IsEmpty(properties.WindDirection);
Assert.IsEmpty(properties.WindSpeed);
Assert.IsEmpty(properties.Comment);
mocks.VerifyAll();
}
private static bool AreHydraulicBoundaryDatabasesEquivalent(HydraulicBoundaryDatabase hydraulicBoundaryDatabase,
HydraulicBoundaryDatabase otherHydraulicBoundaryDatabase)
{
return(hydraulicBoundaryDatabase.Version == otherHydraulicBoundaryDatabase.Version &&
AreHydraulicBoundaryLocationConfigurationSettingsEquivalent(hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings,
otherHydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings));
}
public void GetProperties_WithLinkedDatabase_ReturnsExpectedValues()
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = CreateLinkedHydraulicBoundaryDatabase();
// Precondition
Assert.IsTrue(hydraulicBoundaryDatabase.IsLinked());
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
Assert.AreEqual(hydraulicBoundaryDatabase.FilePath, properties.HrdFilePath);
HydraulicLocationConfigurationSettings configurationSettings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(configurationSettings.FilePath, properties.HlcdFilePath);
Assert.AreEqual(configurationSettings.FilePath, properties.HlcdFilePathReadOnly);
Assert.AreEqual(configurationSettings.UsePreprocessorClosure, properties.UsePreprocessorClosure);
Assert.AreEqual(configurationSettings.ScenarioName, properties.ScenarioName);
Assert.AreEqual(configurationSettings.Year.ToString(), properties.Year);
Assert.AreEqual(configurationSettings.Scope, properties.Scope);
Assert.AreEqual(configurationSettings.SeaLevel, properties.SeaLevel);
Assert.AreEqual(configurationSettings.RiverDischarge, properties.RiverDischarge);
Assert.AreEqual(configurationSettings.LakeLevel, properties.LakeLevel);
Assert.AreEqual(configurationSettings.WindDirection, properties.WindDirection);
Assert.AreEqual(configurationSettings.WindSpeed, properties.WindSpeed);
Assert.AreEqual(configurationSettings.Comment, properties.Comment);
mocks.VerifyAll();
}
/// <summary>
/// Performs validation over the given input parameters. Error and status information is logged
/// during the execution of the operation.
/// </summary>
/// <param name="waveConditionsInput">The input of the calculation.</param>
/// <param name="assessmentLevel">The assessment level to use for determining water levels.</param>
/// <param name="hydraulicBoundaryDatabase">The hydraulic boundary database to validate.</param>
/// <returns><c>true</c> if there were no validation errors; <c>false</c> otherwise.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="waveConditionsInput"/> or
/// <paramref name="hydraulicBoundaryDatabase"/> is <c>null</c>.</exception>
public static bool Validate(WaveConditionsInput waveConditionsInput,
RoundedDouble assessmentLevel,
HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (waveConditionsInput == null)
{
throw new ArgumentNullException(nameof(waveConditionsInput));
}
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
CalculationServiceHelper.LogValidationBegin();
string[] messages = ValidateInput(hydraulicBoundaryDatabase,
waveConditionsInput,
assessmentLevel);
CalculationServiceHelper.LogMessagesAsError(messages);
CalculationServiceHelper.LogValidationEnd();
return(!messages.Any());
}
public void UsePreprocessor_SetNewValue_ValueSetToHydraulicBoundaryDatabaseAndObserversNotified(bool usePreprocessor)
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
var observer = mocks.StrictMock <IObserver>();
observer.Expect(o => o.UpdateObserver());
mocks.ReplayAll();
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = !usePreprocessor,
PreprocessorDirectory = "Preprocessor"
}
};
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
hydraulicBoundaryDatabase.Attach(observer);
// Call
properties.UsePreprocessor = usePreprocessor;
// Assert
Assert.AreEqual(usePreprocessor, hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessor);
mocks.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 PreprocessorDirectory_SetNewValue_ValueSetToHydraulicBoundaryDatabase()
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
const string newPreprocessorDirectory = @"C:/path";
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
HydraulicLocationConfigurationSettings =
{
CanUsePreprocessor = true,
UsePreprocessor = true,
PreprocessorDirectory = "Preprocessor"
}
};
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Call
properties.PreprocessorDirectory = newPreprocessorDirectory;
// Assert
Assert.AreEqual(newPreprocessorDirectory, hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.PreprocessorDirectory);
mocks.VerifyAll();
}
public void Update_WithReadHydraulicLocationConfigurationDatabaseSettings_SetsExpectedValuesAndDoesNotLog()
{
// Setup
const string hlcdFilePath = "some/file/path";
var handler = new HydraulicLocationConfigurationDatabaseUpdateHandler(CreateAssessmentSection());
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase();
ReadHydraulicLocationConfigurationDatabaseSettings readSettings = ReadHydraulicLocationConfigurationDatabaseSettingsTestFactory.Create();
bool usePreprocessorClosure = new Random(21).NextBoolean();
// Call
void Call() => handler.Update(hydraulicBoundaryDatabase, readSettings, usePreprocessorClosure, hlcdFilePath);
// Assert
TestHelper.AssertLogMessagesCount(Call, 0);
HydraulicLocationConfigurationSettings settings = hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings;
Assert.AreEqual(hlcdFilePath, settings.FilePath);
Assert.AreEqual(readSettings.ScenarioName, settings.ScenarioName);
Assert.AreEqual(readSettings.Year, settings.Year);
Assert.AreEqual(readSettings.Scope, settings.Scope);
Assert.AreEqual(usePreprocessorClosure, settings.UsePreprocessorClosure);
Assert.AreEqual(readSettings.SeaLevel, settings.SeaLevel);
Assert.AreEqual(readSettings.RiverDischarge, settings.RiverDischarge);
Assert.AreEqual(readSettings.LakeLevel, settings.LakeLevel);
Assert.AreEqual(readSettings.WindDirection, settings.WindDirection);
Assert.AreEqual(readSettings.WindSpeed, settings.WindSpeed);
Assert.AreEqual(readSettings.Comment, settings.Comment);
}
public void DynamicVisibleValidationMethod_DependingOnHydraulicDatabaseLinkStatus_ReturnsExpectedVisibility(bool isHydraulicBoundaryDatabaseLinked)
{
// Setup
var mocks = new MockRepository();
var importHandler = mocks.Stub <IHydraulicLocationConfigurationDatabaseImportHandler>();
mocks.ReplayAll();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = isHydraulicBoundaryDatabaseLinked
? CreateLinkedHydraulicBoundaryDatabase()
: new HydraulicBoundaryDatabase();
// Call
var properties = new HydraulicBoundaryDatabaseProperties(hydraulicBoundaryDatabase, importHandler);
// Assert
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.HrdFilePath)));
Assert.IsFalse(properties.DynamicVisibleValidationMethod(nameof(properties.UsePreprocessor)));
Assert.IsFalse(properties.DynamicVisibleValidationMethod(nameof(properties.PreprocessorDirectory)));
Assert.IsFalse(properties.DynamicVisibleValidationMethod(nameof(properties.PreprocessorDirectoryReadOnly)));
Assert.AreEqual(isHydraulicBoundaryDatabaseLinked, properties.DynamicVisibleValidationMethod(nameof(properties.HlcdFilePath)));
Assert.AreEqual(!isHydraulicBoundaryDatabaseLinked, properties.DynamicVisibleValidationMethod(nameof(properties.HlcdFilePathReadOnly)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.ScenarioName)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Year)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Scope)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.SeaLevel)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.RiverDischarge)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.LakeLevel)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.WindDirection)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.WindSpeed)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Comment)));
mocks.VerifyAll();
}
public void Calculate_HydraulicDatabaseDoesNotExist_LogsError()
{
// Setup
var hydraulicBoundaryDatabase = new HydraulicBoundaryDatabase
{
FilePath = "Does not exist"
};
var mocks = new MockRepository();
var viewParent = mocks.Stub <IViewParent>();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase)
.Return(hydraulicBoundaryDatabase);
mocks.ReplayAll();
var guiService = new DuneLocationCalculationGuiService(viewParent);
// Call
void Call() => guiService.Calculate(Enumerable.Empty <DuneLocationCalculation>(), 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 IEnumerable <IObservable> Update(HydraulicBoundaryDatabase hydraulicBoundaryDatabase,
ReadHydraulicLocationConfigurationDatabaseSettings readHydraulicLocationConfigurationDatabaseSettings,
bool usePreprocessorClosure,
string hlcdFilePath)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
if (hlcdFilePath == null)
{
throw new ArgumentNullException(nameof(hlcdFilePath));
}
HydraulicLocationConfigurationSettingsUpdateHelper.SetHydraulicLocationConfigurationSettings(
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings,
readHydraulicLocationConfigurationDatabaseSettings, usePreprocessorClosure, hlcdFilePath);
var changedObjects = new List <IObservable>
{
hydraulicBoundaryDatabase
};
changedObjects.AddRange(RiskeerDataSynchronizationService.ClearHydraulicBoundaryLocationCalculationOutput(assessmentSection));
changedObjects.AddRange(RiskeerDataSynchronizationService.ClearFailureMechanismCalculationOutputs(assessmentSection));
return(changedObjects);
}
/// <summary>
/// Validates the connection of the provided hydraulic boundary database.
/// </summary>
/// <param name="hydraulicBoundaryDatabase">The hydraulic boundary database to validate.</param>
/// <returns>An error message if a problem was found; <c>null</c> in case no problems were found.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="hydraulicBoundaryDatabase"/> is <c>null</c>.</exception>
public static string Validate(HydraulicBoundaryDatabase hydraulicBoundaryDatabase)
{
if (hydraulicBoundaryDatabase == null)
{
throw new ArgumentNullException(nameof(hydraulicBoundaryDatabase));
}
if (!hydraulicBoundaryDatabase.IsLinked())
{
return(Resources.HydraulicBoundaryDatabaseConnectionValidator_No_hydraulic_boundary_database_imported);
}
string validationProblem = HydraulicBoundaryDatabaseHelper.ValidateFilesForCalculation(
hydraulicBoundaryDatabase.FilePath,
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.FilePath,
hydraulicBoundaryDatabase.EffectivePreprocessorDirectory(),
hydraulicBoundaryDatabase.HydraulicLocationConfigurationSettings.UsePreprocessorClosure);
if (!string.IsNullOrEmpty(validationProblem))
{
return(string.Format(Resources.Hydraulic_boundary_database_connection_failed_0_,
validationProblem));
}
return(null);
}
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 CreateCalculationActivitiesForFailureMechanism_WithValidData_ExpectedInputSetToActivities()
{
// Setup
AssessmentSectionStub assessmentSection = CreateAssessmentSection();
WaveImpactAsphaltCoverFailureMechanism failureMechanism = new WaveImpactAsphaltCoverFailureMechanism();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1");
SetHydraulicBoundaryLocationToAssessmentSection(assessmentSection, hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation);
WaveImpactAsphaltCoverWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation);
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities =
WaveImpactAsphaltCoverWaveConditionsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism,
assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(WaveImpactAsphaltCoverWaveConditionsCalculationActivity));
Assert.AreEqual(2, activities.Count());
RoundedDouble assessmentLevel = assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Single().Output.Result;
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(0), calculation1, assessmentLevel, hydraulicBoundaryDatabase);
AssertWaveImpactAsphaltCoverWaveConditionsCalculationActivity(activities.ElementAt(1), calculation2, assessmentLevel, hydraulicBoundaryDatabase);
}
public void Import_CancelImportDuringDialogInteraction_GenerateCanceledLogMessageAndReturnsFalse()
{
// Setup
var mocks = new MockRepository();
var handler = mocks.StrictMock <IHydraulicLocationConfigurationDatabaseUpdateHandler>();
handler.Expect(h => h.InquireConfirmation()).Return(false);
mocks.ReplayAll();
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = CreateHydraulicBoundaryDatabase(validHrdFilePath);
var importer = new HydraulicLocationConfigurationDatabaseImporter(new HydraulicLocationConfigurationSettings(), handler,
hydraulicBoundaryDatabase, validHlcdFilePath);
var importResult = true;
// Call
Action call = () => importResult = importer.Import();
// Assert
const string expectedMessage = "HLCD bestand importeren afgebroken. Geen gegevens gewijzigd.";
TestHelper.AssertLogMessageWithLevelIsGenerated(call, Tuple.Create(expectedMessage, LogLevelConstant.Info), 1);
Assert.IsFalse(importResult);
mocks.VerifyAll();
}
