Index: Riskeer/Integration/src/Riskeer.Integration.IO/Handlers/IHydraulicBoundaryDataUpdateHandler.cs =================================================================== diff -u --- Riskeer/Integration/src/Riskeer.Integration.IO/Handlers/IHydraulicBoundaryDataUpdateHandler.cs (revision 0) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Handlers/IHydraulicBoundaryDataUpdateHandler.cs (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -0,0 +1,78 @@ +// Copyright (C) Stichting Deltares 2022. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using Core.Common.Base; +using Riskeer.Common.Data.Hydraulics; +using Riskeer.HydraRing.IO.HydraulicBoundaryDatabase; +using Riskeer.HydraRing.IO.HydraulicLocationConfigurationDatabase; + +namespace Riskeer.Integration.IO.Handlers +{ + /// + /// Interface for an object that can properly update . + /// + public interface IHydraulicBoundaryDataUpdateHandler + { + /// + /// Checks whether confirmation is required before updating the . + /// + /// The hydraulic boundary data. + /// The read hydraulic boundary database. + /// true when confirmation is required; false otherwise. + /// Thrown when any parameter is null. + bool IsConfirmationRequired(HydraulicBoundaryData hydraulicBoundaryData, ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase); + + /// + /// Gets confirmation for updating the . + /// + /// true when confirmation is given; false otherwise. + bool InquireConfirmation(); + + /// + /// Updates the and its dependent data with the + /// and the . + /// + /// The hydraulic boundary data to update. + /// The read hydraulic boundary database to update with. + /// The read hydraulic location configuration database to + /// update with. + /// The location ids that should be excluded. + /// The file path of the read hydraulic boundary database. + /// The file path of the hlcd. + /// All objects that have been affected by the update. + /// Thrown when any parameter is null. + /// Thrown when the cannot be updated with + /// . + IEnumerable Update(HydraulicBoundaryData hydraulicBoundaryData, + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase, + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase, + IEnumerable excludedLocationIds, + string hydraulicBoundaryDatabaseFilePath, + string hlcdFilePath); + + /// + /// Perform post-update actions. + /// + void DoPostUpdateActions(); + } +} \ No newline at end of file Fisheye: Tag d3da87d7d703f1a7b64882c937564f55ae859d96 refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.IO/Handlers/IHydraulicBoundaryDatabaseUpdateHandler.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Integration/src/Riskeer.Integration.IO/Importers/HydraulicBoundaryDatabaseImporter.cs =================================================================== diff -u -rb4a746fe113289ad3090e8a99a655862902fbb34 -rd3da87d7d703f1a7b64882c937564f55ae859d96 --- Riskeer/Integration/src/Riskeer.Integration.IO/Importers/HydraulicBoundaryDatabaseImporter.cs (.../HydraulicBoundaryDatabaseImporter.cs) (revision b4a746fe113289ad3090e8a99a655862902fbb34) +++ Riskeer/Integration/src/Riskeer.Integration.IO/Importers/HydraulicBoundaryDatabaseImporter.cs (.../HydraulicBoundaryDatabaseImporter.cs) (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -45,7 +45,7 @@ { private const int numberOfSteps = 4; private readonly List changedObservables = new List(); - private readonly IHydraulicBoundaryDatabaseUpdateHandler updateHandler; + private readonly IHydraulicBoundaryDataUpdateHandler updateHandler; /// /// Creates a new instance of . @@ -54,7 +54,7 @@ /// The object responsible for updating the . /// The path of the hydraulic boundary database file to import from. /// Thrown when any parameter is null. - public HydraulicBoundaryDatabaseImporter(HydraulicBoundaryData importTarget, IHydraulicBoundaryDatabaseUpdateHandler updateHandler, + public HydraulicBoundaryDatabaseImporter(HydraulicBoundaryData importTarget, IHydraulicBoundaryDataUpdateHandler updateHandler, string filePath) : base(filePath, importTarget) { Index: Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/HydraulicBoundaryDataUpdateHandler.cs =================================================================== diff -u --- Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/HydraulicBoundaryDataUpdateHandler.cs (revision 0) +++ Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/HydraulicBoundaryDataUpdateHandler.cs (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -0,0 +1,235 @@ +// Copyright (C) Stichting Deltares 2022. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Windows.Forms; +using Core.Common.Base; +using Riskeer.Common.Data.Hydraulics; +using Riskeer.DuneErosion.Plugin.Handlers; +using Riskeer.HydraRing.IO.HydraulicBoundaryDatabase; +using Riskeer.HydraRing.IO.HydraulicLocationConfigurationDatabase; +using Riskeer.Integration.Data; +using Riskeer.Integration.IO.Handlers; +using Riskeer.Integration.Plugin.Helpers; +using Riskeer.Integration.Plugin.Properties; +using Riskeer.Integration.Service; +using CoreCommonBaseResources = Core.Common.Base.Properties.Resources; + +namespace Riskeer.Integration.Plugin.Handlers +{ + /// + /// Class that can properly update . + /// + public class HydraulicBoundaryDataUpdateHandler : IHydraulicBoundaryDataUpdateHandler + { + private readonly AssessmentSection assessmentSection; + private readonly IDuneLocationsReplacementHandler duneLocationsReplacementHandler; + private bool updateLocations; + + /// + /// Creates a new instance of . + /// + /// The assessment section to update for. + /// The handler to replace dune locations. + /// Thrown when any parameter is null. + public HydraulicBoundaryDataUpdateHandler(AssessmentSection assessmentSection, + IDuneLocationsReplacementHandler duneLocationsReplacementHandler) + { + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + if (duneLocationsReplacementHandler == null) + { + throw new ArgumentNullException(nameof(duneLocationsReplacementHandler)); + } + + this.assessmentSection = assessmentSection; + this.duneLocationsReplacementHandler = duneLocationsReplacementHandler; + } + + public bool IsConfirmationRequired(HydraulicBoundaryData hydraulicBoundaryData, ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase) + { + if (hydraulicBoundaryData == null) + { + throw new ArgumentNullException(nameof(hydraulicBoundaryData)); + } + + if (readHydraulicBoundaryDatabase == null) + { + throw new ArgumentNullException(nameof(readHydraulicBoundaryDatabase)); + } + + return hydraulicBoundaryData.IsLinked() && hydraulicBoundaryData.Version != readHydraulicBoundaryDatabase.Version; + } + + public bool InquireConfirmation() + { + DialogResult result = MessageBox.Show(Resources.HydraulicBoundaryDatabaseUpdateHandler_Confirm_clear_hydraulicBoundaryDatabase_dependent_data, + CoreCommonBaseResources.Confirm, + MessageBoxButtons.OKCancel); + return result == DialogResult.OK; + } + + public IEnumerable Update(HydraulicBoundaryData hydraulicBoundaryData, ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase, + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase, + IEnumerable excludedLocationIds, string hydraulicBoundaryDatabaseFilePath, string hlcdFilePath) + { + if (hydraulicBoundaryData == null) + { + throw new ArgumentNullException(nameof(hydraulicBoundaryData)); + } + + if (readHydraulicBoundaryDatabase == null) + { + throw new ArgumentNullException(nameof(readHydraulicBoundaryDatabase)); + } + + if (readHydraulicLocationConfigurationDatabase == null) + { + throw new ArgumentNullException(nameof(readHydraulicLocationConfigurationDatabase)); + } + + if (excludedLocationIds == null) + { + throw new ArgumentNullException(nameof(excludedLocationIds)); + } + + if (hydraulicBoundaryDatabaseFilePath == null) + { + throw new ArgumentNullException(nameof(hydraulicBoundaryDatabaseFilePath)); + } + + if (hlcdFilePath == null) + { + throw new ArgumentNullException(nameof(hlcdFilePath)); + } + + if (!IsValidReadHydraulicLocationConfigurationDatabase(readHydraulicLocationConfigurationDatabase)) + { + string errorMessage = $"{nameof(readHydraulicLocationConfigurationDatabase)} must be null or contain exactly one item for " + + "the collection of hydraulic location configuration database settings."; + throw new ArgumentException(errorMessage); + } + + var changedObjects = new List(); + + updateLocations = !hydraulicBoundaryData.IsLinked() || hydraulicBoundaryData.Version != readHydraulicBoundaryDatabase.Version; + + if (updateLocations) + { + hydraulicBoundaryData.FilePath = hydraulicBoundaryDatabaseFilePath; + hydraulicBoundaryData.Version = readHydraulicBoundaryDatabase.Version; + + SetLocations(hydraulicBoundaryData, readHydraulicBoundaryDatabase.Locations, + readHydraulicLocationConfigurationDatabase.LocationIdMappings, + excludedLocationIds.ToArray()); + + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryData.Locations); + + duneLocationsReplacementHandler.Replace(hydraulicBoundaryData.Locations); + + changedObjects.AddRange(GetLocationsAndCalculationsObservables(hydraulicBoundaryData)); + changedObjects.AddRange(RiskeerDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(assessmentSection)); + } + else + { + if (hydraulicBoundaryData.FilePath != hydraulicBoundaryDatabaseFilePath) + { + hydraulicBoundaryData.FilePath = hydraulicBoundaryDatabaseFilePath; + } + } + + HydraulicLocationConfigurationSettingsUpdateHelper.SetHydraulicLocationConfigurationSettings( + hydraulicBoundaryData.HydraulicLocationConfigurationSettings, + readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings?.Single(), + readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure, + hlcdFilePath); + + return changedObjects; + } + + public void DoPostUpdateActions() + { + if (updateLocations) + { + duneLocationsReplacementHandler.DoPostReplacementUpdates(); + } + } + + private static bool IsValidReadHydraulicLocationConfigurationDatabase(ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase) + { + return readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings == null + || readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings.Count() == 1; + } + + private IEnumerable GetLocationsAndCalculationsObservables(HydraulicBoundaryData hydraulicBoundaryData) + { + var locationsAndCalculationsObservables = new List + { + hydraulicBoundaryData.Locations, + assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, + assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, + assessmentSection.DuneErosion.DuneLocations, + assessmentSection.DuneErosion.DuneLocationCalculationsForUserDefinedTargetProbabilities + }; + + locationsAndCalculationsObservables.AddRange(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities + .Select(element => element.HydraulicBoundaryLocationCalculations)); + locationsAndCalculationsObservables.AddRange(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities + .Select(element => element.HydraulicBoundaryLocationCalculations)); + locationsAndCalculationsObservables.AddRange(assessmentSection.DuneErosion.DuneLocationCalculationsForUserDefinedTargetProbabilities + .Select(element => element.DuneLocationCalculations)); + + return locationsAndCalculationsObservables; + } + + private static void SetLocations(HydraulicBoundaryData hydraulicBoundaryData, IEnumerable readLocations, + IEnumerable locationIdMappings, long[] excludedLocationIds) + { + hydraulicBoundaryData.Locations.Clear(); + + Array.Sort(excludedLocationIds); + + foreach (ReadHydraulicBoundaryLocation readLocation in readLocations) + { + long locationConfigurationId = locationIdMappings.Where(m => m.HrdLocationId == readLocation.Id) + .Select(m => m.HlcdLocationId) + .SingleOrDefault(); + + if (locationConfigurationId != 0 && ShouldInclude(excludedLocationIds, locationConfigurationId)) + { + hydraulicBoundaryData.Locations.Add(new HydraulicBoundaryLocation(locationConfigurationId, readLocation.Name, + readLocation.CoordinateX, readLocation.CoordinateY)); + } + } + } + + private static bool ShouldInclude(long[] excludedLocationIds, long locationId) + { + int matchingIndex = Array.BinarySearch(excludedLocationIds, locationId); + return matchingIndex < 0; + } + } +} \ No newline at end of file Fisheye: Tag d3da87d7d703f1a7b64882c937564f55ae859d96 refers to a dead (removed) revision in file `Riskeer/Integration/src/Riskeer.Integration.Plugin/Handlers/HydraulicBoundaryDatabaseUpdateHandler.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs =================================================================== diff -u -r6a263ea3b762067b9c56c3996c37e23d9f62af13 -rd3da87d7d703f1a7b64882c937564f55ae859d96 --- Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs (.../RiskeerPlugin.cs) (revision 6a263ea3b762067b9c56c3996c37e23d9f62af13) +++ Riskeer/Integration/src/Riskeer.Integration.Plugin/RiskeerPlugin.cs (.../RiskeerPlugin.cs) (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -568,7 +568,7 @@ FileFilterGenerator = new FileFilterGenerator(Resources.HydraulicBoundaryDatabase_FilePath_Extension, Resources.HydraulicBoundaryDatabase_file_filter_Description), CreateFileImporter = (context, filePath) => new HydraulicBoundaryDatabaseImporter( - context.WrappedData, new HydraulicBoundaryDatabaseUpdateHandler(context.AssessmentSection, + context.WrappedData, new HydraulicBoundaryDataUpdateHandler(context.AssessmentSection, new DuneLocationsReplacementHandler( Gui.ViewCommands, context.AssessmentSection.DuneErosion)), filePath) Index: Riskeer/Integration/test/Riskeer.Integration.IO.Test/Importers/HydraulicBoundaryDatabaseImporterTest.cs =================================================================== diff -u -rf1f59fc7d82765987155006b83f7410343c73192 -rd3da87d7d703f1a7b64882c937564f55ae859d96 --- Riskeer/Integration/test/Riskeer.Integration.IO.Test/Importers/HydraulicBoundaryDatabaseImporterTest.cs (.../HydraulicBoundaryDatabaseImporterTest.cs) (revision f1f59fc7d82765987155006b83f7410343c73192) +++ Riskeer/Integration/test/Riskeer.Integration.IO.Test/Importers/HydraulicBoundaryDatabaseImporterTest.cs (.../HydraulicBoundaryDatabaseImporterTest.cs) (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -61,7 +61,7 @@ { // Setup var mocks = new MockRepository(); - var updateHandler = mocks.Stub(); + var updateHandler = mocks.Stub(); mocks.ReplayAll(); // Call @@ -77,7 +77,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); mocks.ReplayAll(); string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.IO, Path.DirectorySeparatorChar.ToString()); @@ -99,7 +99,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); mocks.ReplayAll(); string path = TestHelper.GetTestDataPath(TestDataPath.Riskeer.Integration.IO, "I_dont_exist"); @@ -121,7 +121,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); mocks.ReplayAll(); string path = Path.Combine(testDataPath, "corruptschema.sqlite"); @@ -143,7 +143,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); mocks.ReplayAll(); string path = Path.Combine(testDataPath, "empty.sqlite"); @@ -165,7 +165,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -188,7 +188,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -212,7 +212,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -238,7 +238,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -262,7 +262,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -286,7 +286,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -309,7 +309,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -337,7 +337,7 @@ var hydraulicBoundaryData = new HydraulicBoundaryData(); var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Expect(h => h.IsConfirmationRequired(Arg.Is.Same(hydraulicBoundaryData), Arg.Is.NotNull)) .WhenCalled(invocation => @@ -382,7 +382,7 @@ var hydraulicBoundaryData = new HydraulicBoundaryData(); var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Expect(h => h.IsConfirmationRequired(null, null)) .IgnoreArguments() .Return(false); @@ -429,7 +429,7 @@ var hydraulicBoundaryData = new HydraulicBoundaryData(); var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Expect(h => h.IsConfirmationRequired(null, null)) .IgnoreArguments() .Return(false); @@ -471,7 +471,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.Stub(); + var handler = mocks.Stub(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); handler.Stub(h => h.Update(null, null, null, null, null, null)).IgnoreArguments().Return(Enumerable.Empty()); mocks.ReplayAll(); @@ -502,7 +502,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Expect(h => h.IsConfirmationRequired(Arg.Is.NotNull, Arg.Is.NotNull)) .WhenCalled(invocation => @@ -535,7 +535,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); mocks.ReplayAll(); @@ -567,7 +567,7 @@ { // Setup var mocks = new MockRepository(); - var handler = mocks.Stub(); + var handler = mocks.Stub(); handler.Stub(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); handler.Stub(h => h.Update(null, null, null, null, null, null)).IgnoreArguments().Return(Enumerable.Empty()); mocks.ReplayAll(); @@ -609,7 +609,7 @@ var observable2 = mocks.StrictMock(); observable2.Expect(o => o.NotifyObservers()); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); handler.Expect(h => h.IsConfirmationRequired(null, null)).IgnoreArguments().Return(false); handler.Expect(h => h.Update(Arg.Is.NotNull, Arg.Is.NotNull, @@ -647,7 +647,7 @@ var mocks = new MockRepository(); var observer = mocks.StrictMock(); - var handler = mocks.StrictMock(); + var handler = mocks.StrictMock(); var importer = new HydraulicBoundaryDatabaseImporter(hydraulicBoundaryData, handler, validFilePath); handler.Expect(h => h.IsConfirmationRequired(null, null)).IgnoreArguments() .WhenCalled(invocation => importer.Cancel()) Index: Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/HydraulicBoundaryDataUpdateHandlerTest.cs =================================================================== diff -u --- Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/HydraulicBoundaryDataUpdateHandlerTest.cs (revision 0) +++ Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/HydraulicBoundaryDataUpdateHandlerTest.cs (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -0,0 +1,1006 @@ +// Copyright (C) Stichting Deltares 2022. All rights reserved. +// +// This file is part of Riskeer. +// +// Riskeer is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. +// +// This program is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. +// +// You should have received a copy of the GNU General Public License +// along with this program. If not, see . +// +// All names, logos, and references to "Deltares" are registered trademarks of +// Stichting Deltares and remain full property of Stichting Deltares at all times. +// All rights reserved. + +using System; +using System.Collections.Generic; +using System.Linq; +using Core.Common.Base; +using Core.Common.TestUtil; +using NUnit.Extensions.Forms; +using NUnit.Framework; +using Rhino.Mocks; +using Riskeer.Common.Data.AssessmentSection; +using Riskeer.Common.Data.Calculation; +using Riskeer.Common.Data.FailureMechanism; +using Riskeer.Common.Data.Hydraulics; +using Riskeer.Common.Data.TestUtil; +using Riskeer.DuneErosion.Plugin.Handlers; +using Riskeer.HydraRing.IO.HydraulicBoundaryDatabase; +using Riskeer.HydraRing.IO.HydraulicLocationConfigurationDatabase; +using Riskeer.HydraRing.IO.TestUtil; +using Riskeer.Integration.Data; +using Riskeer.Integration.IO.Handlers; +using Riskeer.Integration.Plugin.Handlers; +using Riskeer.Integration.TestUtil; +using Riskeer.MacroStabilityInwards.Data; +using Riskeer.Piping.Data.SemiProbabilistic; +using Riskeer.Piping.Data.TestUtil; + +namespace Riskeer.Integration.Plugin.Test.Handlers +{ + [TestFixture] + public class HydraulicBoundaryDataUpdateHandlerTest : NUnitFormTest + { + [Test] + public void Constructor_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + // Call + void Call() => new HydraulicBoundaryDataUpdateHandler(null, duneLocationsReplacementHandler); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("assessmentSection", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void Constructor_DuneLocationsReplacementHandlerNull_ThrowsArgumentNullException() + { + // Call + void Call() => new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("duneLocationsReplacementHandler", exception.ParamName); + } + + [Test] + public void Constructor_ExpectedValues() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + // Call + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Assert + Assert.IsInstanceOf(handler); + mocks.VerifyAll(); + } + + [Test] + public void IsConfirmationRequired_HydraulicBoundaryDataNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.IsConfirmationRequired(null, ReadHydraulicBoundaryDatabaseTestFactory.Create()); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("hydraulicBoundaryData", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void IsConfirmationRequired_ReadHydraulicBoundaryDatabaseNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.IsConfirmationRequired(new HydraulicBoundaryData(), null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("readHydraulicBoundaryDatabase", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void IsConfirmationRequired_HydraulicBoundaryDataNotLinked_ReturnsFalse() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + bool confirmationRequired = handler.IsConfirmationRequired(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create()); + + // Assert + Assert.IsFalse(confirmationRequired); + mocks.VerifyAll(); + } + + [Test] + public void IsConfirmationRequired_HydraulicBoundaryDataLinkedAndReadDatabaseSameVersion_ReturnsFalse() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = "some/file/path", + Version = readHydraulicBoundaryDatabase.Version + }; + + // Call + bool confirmationRequired = handler.IsConfirmationRequired(hydraulicBoundaryData, readHydraulicBoundaryDatabase); + + // Assert + Assert.IsFalse(confirmationRequired); + mocks.VerifyAll(); + } + + [Test] + public void IsConfirmationRequired_HydraulicBoundaryDataLinkedAndReadDatabaseDifferentVersion_ReturnsTrue() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = "some/file/path", + Version = "1" + }; + + // Call + bool confirmationRequired = handler.IsConfirmationRequired(hydraulicBoundaryData, ReadHydraulicBoundaryDatabaseTestFactory.Create()); + + // Assert + Assert.IsTrue(confirmationRequired); + mocks.VerifyAll(); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void InquireConfirmation_ClickDialog_ReturnsExpectedResult(bool clickOk) + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + string dialogTitle = null, dialogMessage = null; + DialogBoxHandler = (name, wnd) => + { + var tester = new MessageBoxTester(wnd); + dialogTitle = tester.Title; + dialogMessage = tester.Text; + if (clickOk) + { + tester.ClickOk(); + } + else + { + tester.ClickCancel(); + } + }; + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + bool result = handler.InquireConfirmation(); + + // Assert + Assert.AreEqual(clickOk, result); + + Assert.AreEqual("Bevestigen", dialogTitle); + Assert.AreEqual("U heeft een ander hydraulische belastingendatabase bestand geselecteerd. Als gevolg hiervan moet de uitvoer van alle ervan afhankelijke berekeningen verwijderd worden." + + Environment.NewLine + + Environment.NewLine + + "Wilt u doorgaan?", + dialogMessage); + mocks.VerifyAll(); + } + + [Test] + public void Update_HydraulicBoundaryDataNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(null, ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), "", ""); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("hydraulicBoundaryData", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void Update_ReadHydraulicBoundaryDatabaseNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), null, + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), "", ""); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("readHydraulicBoundaryDatabase", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void Update_ReadHydraulicLocationConfigurationDatabaseNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create(), + null, Enumerable.Empty(), "", ""); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("readHydraulicLocationConfigurationDatabase", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void Update_ExcludedLocationIdsNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), null, "", ""); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("excludedLocationIds", exception.ParamName); + } + + [Test] + public void Update_HydraulicBoundaryDatabaseFilePathNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), Enumerable.Empty(), + null, ""); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("hydraulicBoundaryDatabaseFilePath", exception.ParamName); + } + + [Test] + public void Update_HlcdFilePathNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), Enumerable.Empty(), + "", null); + + // Assert + var exception = Assert.Throws(Call); + Assert.AreEqual("hlcdFilePath", exception.ParamName); + } + + [Test] + [TestCaseSource(nameof(GetInvalidReadHydraulicBoundaryDatabaseConfigurations))] + public void Update_ReadHydraulicLocationConfigurationDatabaseHasUnequalToOneSettings_ThrowsArgumentException( + ReadHydraulicLocationConfigurationDatabase configurationDatabase) + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + var handler = new HydraulicBoundaryDataUpdateHandler(CreateAssessmentSection(), duneLocationsReplacementHandler); + + // Call + void Call() => handler.Update(new HydraulicBoundaryData(), ReadHydraulicBoundaryDatabaseTestFactory.Create(), + configurationDatabase, Enumerable.Empty(), "", ""); + + // Assert + const string expectedMessage = "readHydraulicLocationConfigurationDatabase must be null or contain " + + "exactly one item for the collection of hydraulic location configuration database settings."; + TestHelper.AssertThrowsArgumentExceptionAndTestMessage(Call, expectedMessage); + } + + [Test] + public void Update_FilePathAndVersionSame_NothingUpdatesAndReturnsEmptyCollection() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create(); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = hydraulicBoundaryDatabaseFilePath, + Version = readHydraulicBoundaryDatabase.Version, + Locations = + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + } + }; + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryData.Locations); + + HydraulicBoundaryLocation[] locations = hydraulicBoundaryData.Locations.ToArray(); + + // Call + IEnumerable changedObjects = handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Assert + CollectionAssert.IsEmpty(changedObjects); + Assert.AreEqual(hydraulicBoundaryDatabaseFilePath, hydraulicBoundaryData.FilePath); + Assert.AreEqual("version", hydraulicBoundaryData.Version); + AssertHydraulicBoundaryLocationsAndCalculations(locations, assessmentSection); + mocks.VerifyAll(); + } + + [Test] + public void Update_VersionSameAndFilePathNotSame_UpdatesFilePathAndReturnsEmptyCollection() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + mocks.ReplayAll(); + + const string newHydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string newHlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create(); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = "old/file/path", + Version = readHydraulicBoundaryDatabase.Version, + Locations = + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + } + }; + HydraulicBoundaryDataTestHelper.SetHydraulicLocationConfigurationSettings(hydraulicBoundaryData); + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryData.Locations); + + HydraulicBoundaryLocation[] locations = hydraulicBoundaryData.Locations.ToArray(); + + // Call + IEnumerable changedObjects = handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), newHydraulicBoundaryDatabaseFilePath, newHlcdFilePath); + + // Assert + CollectionAssert.IsEmpty(changedObjects); + Assert.AreEqual(newHydraulicBoundaryDatabaseFilePath, hydraulicBoundaryData.FilePath); + Assert.AreEqual(newHlcdFilePath, hydraulicBoundaryData.HydraulicLocationConfigurationSettings.FilePath); + Assert.AreEqual("version", hydraulicBoundaryData.Version); + AssertHydraulicBoundaryLocationsAndCalculations(locations, assessmentSection); + mocks.VerifyAll(); + } + + [Test] + public void Update_HydraulicBoundaryDataLinkedAndVersionNotSame_RemovesOldLocationsAndCalculations() + { + // Setup + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = hydraulicBoundaryDatabaseFilePath, + Version = "1", + Locations = + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + } + }; + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + duneLocationsReplacementHandler.Expect(h => h.Replace(Arg>.Is.NotNull)) + .WhenCalled(invocation => + { + Assert.AreSame(hydraulicBoundaryData.Locations, invocation.Arguments[0]); + }); + mocks.ReplayAll(); + + AssessmentSection assessmentSection = CreateAssessmentSection(); + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryData.Locations); + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + HydraulicBoundaryLocation[] oldLocations = hydraulicBoundaryData.Locations.ToArray(); + + // Precondition + Assert.IsTrue(hydraulicBoundaryData.IsLinked()); + + // Call + handler.Update(hydraulicBoundaryData, ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Assert + CollectionAssert.IsNotSubsetOf(oldLocations, hydraulicBoundaryData.Locations); + CollectionAssert.IsNotSubsetOf(oldLocations, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Select(hblc => hblc.HydraulicBoundaryLocation)); + CollectionAssert.IsNotSubsetOf(oldLocations, assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Select(hblc => hblc.HydraulicBoundaryLocation)); + + foreach (HydraulicBoundaryLocationCalculationsForTargetProbability targetProbability in assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities) + { + CollectionAssert.IsNotSubsetOf(oldLocations, targetProbability.HydraulicBoundaryLocationCalculations.Select(hblc => hblc.HydraulicBoundaryLocation)); + } + + foreach (HydraulicBoundaryLocationCalculationsForTargetProbability targetProbability in assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities) + { + CollectionAssert.IsNotSubsetOf(oldLocations, targetProbability.HydraulicBoundaryLocationCalculations.Select(hblc => hblc.HydraulicBoundaryLocation)); + } + + mocks.VerifyAll(); + } + + [Test] + public void Update_HydraulicBoundaryDataNotLinked_SetsAllData() + { + // Setup + var hydraulicBoundaryData = new HydraulicBoundaryData(); + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + duneLocationsReplacementHandler.Expect(h => h.Replace(Arg>.Is.NotNull)) + .WhenCalled(invocation => + { + Assert.AreSame(hydraulicBoundaryData.Locations, invocation.Arguments[0]); + }); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create(); + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(); + + // Precondition + Assert.IsFalse(hydraulicBoundaryData.IsLinked()); + + // Call + handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + readHydraulicLocationConfigurationDatabase, + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Assert + Assert.IsTrue(hydraulicBoundaryData.IsLinked()); + Assert.AreEqual(hydraulicBoundaryDatabaseFilePath, hydraulicBoundaryData.FilePath); + Assert.AreEqual(readHydraulicBoundaryDatabase.Version, hydraulicBoundaryData.Version); + Assert.AreEqual(hydraulicBoundaryData.HydraulicLocationConfigurationSettings.UsePreprocessorClosure, readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure); + + AssertHydraulicBoundaryLocations(readHydraulicBoundaryDatabase.Locations, readHydraulicLocationConfigurationDatabase, hydraulicBoundaryData.Locations); + AssertHydraulicBoundaryLocationsAndCalculations(hydraulicBoundaryData.Locations, assessmentSection); + mocks.VerifyAll(); + } + + [Test] + public void Update_HrdLocationIdsNotInHlcdLocationIds_ThenLocationsNotAdded() + { + var hydraulicBoundaryData = new HydraulicBoundaryData(); + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + var readHydraulicBoundaryLocationsToInclude = new[] + { + new ReadHydraulicBoundaryLocation(1, "location 1", 1, 1), + new ReadHydraulicBoundaryLocation(2, "location 2", 2, 2) + }; + var readHydraulicBoundaryLocationsToExclude = new[] + { + new ReadHydraulicBoundaryLocation(3, "location 3", 3, 3), + new ReadHydraulicBoundaryLocation(4, "location 4", 4, 4) + }; + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create( + readHydraulicBoundaryLocationsToInclude.Concat(readHydraulicBoundaryLocationsToExclude)); + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(); + + // Precondition + Assert.IsFalse(hydraulicBoundaryData.IsLinked()); + + // Call + handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + readHydraulicLocationConfigurationDatabase, + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Assert + AssertHydraulicBoundaryLocations(readHydraulicBoundaryLocationsToInclude, readHydraulicLocationConfigurationDatabase, hydraulicBoundaryData.Locations); + mocks.VerifyAll(); + } + + [Test] + public void Update_HrdLocationIdsInExcludedLocationIds_LocationsNotAdded() + { + var hydraulicBoundaryData = new HydraulicBoundaryData(); + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + var readHydraulicBoundaryLocationsToExclude = new[] + { + new ReadHydraulicBoundaryLocation(1, "location 1", 1, 1), + new ReadHydraulicBoundaryLocation(2, "location 2", 2, 2) + }; + var readHydraulicBoundaryLocationsToInclude = new[] + { + new ReadHydraulicBoundaryLocation(3, "location 3", 3, 3), + new ReadHydraulicBoundaryLocation(4, "location 4", 4, 4) + }; + + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create( + readHydraulicBoundaryLocationsToExclude.Concat(readHydraulicBoundaryLocationsToInclude)); + + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = ReadHydraulicLocationConfigurationDatabaseTestFactory.Create( + readHydraulicBoundaryLocationsToInclude.Select(l => l.Id)); + + // Precondition + Assert.IsFalse(hydraulicBoundaryData.IsLinked()); + + // Call + handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + readHydraulicLocationConfigurationDatabase, + readHydraulicBoundaryLocationsToExclude.Select(l => l.Id), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Assert + AssertHydraulicBoundaryLocations(readHydraulicBoundaryLocationsToInclude, readHydraulicLocationConfigurationDatabase, hydraulicBoundaryData.Locations); + mocks.VerifyAll(); + } + + [Test] + public void Update_ReadHydraulicLocationConfigurationDatabaseWithScenarioInformation_SetsHydraulicLocationConfigurationSettingsAndDoesNotLog() + { + // Setup + var hydraulicBoundaryData = new HydraulicBoundaryData(); + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = + ReadHydraulicLocationConfigurationDatabaseTestFactory.CreateWithConfigurationSettings(); + + // Precondition + Assert.IsNotNull(readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings); + Assert.AreEqual(1, readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings.Count()); + + // Call + void Call() => handler.Update(hydraulicBoundaryData, + ReadHydraulicBoundaryDatabaseTestFactory.Create(), + readHydraulicLocationConfigurationDatabase, + Enumerable.Empty(), + hydraulicBoundaryDatabaseFilePath, + hlcdFilePath); + + // Assert + TestHelper.AssertLogMessagesCount(Call, 0); + + ReadHydraulicLocationConfigurationDatabaseSettings expectedSettings = readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings + .Single(); + HydraulicLocationConfigurationSettings actualSettings = hydraulicBoundaryData.HydraulicLocationConfigurationSettings; + + Assert.AreEqual(hlcdFilePath, actualSettings.FilePath); + Assert.AreEqual(expectedSettings.ScenarioName, actualSettings.ScenarioName); + Assert.AreEqual(expectedSettings.Year, actualSettings.Year); + Assert.AreEqual(expectedSettings.Scope, actualSettings.Scope); + Assert.AreEqual(readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure, actualSettings.UsePreprocessorClosure); + Assert.AreEqual(expectedSettings.SeaLevel, actualSettings.SeaLevel); + Assert.AreEqual(expectedSettings.RiverDischarge, actualSettings.RiverDischarge); + Assert.AreEqual(expectedSettings.LakeLevel, actualSettings.LakeLevel); + Assert.AreEqual(expectedSettings.WindDirection, actualSettings.WindDirection); + Assert.AreEqual(expectedSettings.WindSpeed, actualSettings.WindSpeed); + Assert.AreEqual(expectedSettings.Comment, actualSettings.Comment); + } + + [Test] + public void Update_ReadHydraulicLocationConfigurationDatabaseWithoutScenarioInformation_SetsDefaultHydraulicLocationConfigurationSettingsAndLogsWarning() + { + // Setup + var hydraulicBoundaryData = new HydraulicBoundaryData(); + + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike); + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase = + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(); + + // Precondition + Assert.IsNull(readHydraulicLocationConfigurationDatabase.ReadHydraulicLocationConfigurationDatabaseSettings); + + // Call + void Call() => handler.Update(hydraulicBoundaryData, + ReadHydraulicBoundaryDatabaseTestFactory.Create(), + readHydraulicLocationConfigurationDatabase, + Enumerable.Empty(), + hydraulicBoundaryDatabaseFilePath, + 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 actualSettings = hydraulicBoundaryData.HydraulicLocationConfigurationSettings; + Assert.AreEqual(hlcdFilePath, actualSettings.FilePath); + Assert.AreEqual("WBI2017", actualSettings.ScenarioName); + Assert.AreEqual(2023, actualSettings.Year); + Assert.AreEqual("WBI2017", actualSettings.Scope); + Assert.AreEqual(readHydraulicLocationConfigurationDatabase.UsePreprocessorClosure, actualSettings.UsePreprocessorClosure); + Assert.AreEqual("Conform WBI2017", actualSettings.SeaLevel); + Assert.AreEqual("Conform WBI2017", actualSettings.RiverDischarge); + Assert.AreEqual("Conform WBI2017", actualSettings.LakeLevel); + Assert.AreEqual("Conform WBI2017", actualSettings.WindDirection); + Assert.AreEqual("Conform WBI2017", actualSettings.WindSpeed); + Assert.AreEqual("Gegenereerd door Riskeer (conform WBI2017)", actualSettings.Comment); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void GivenDatabase_WhenUpdatingDataWithNewLocations_ThenChangedObjectsReturned(bool isLinked) + { + // Given + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var hydraulicBoundaryData = new HydraulicBoundaryData(); + if (isLinked) + { + hydraulicBoundaryData.FilePath = hydraulicBoundaryDatabaseFilePath; + hydraulicBoundaryData.Version = "1"; + hydraulicBoundaryData.Locations.AddRange(new[] + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + }); + } + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + // Precondition + Assert.AreEqual(isLinked, hydraulicBoundaryData.IsLinked()); + + // When + IEnumerable changedObjects = handler.Update(hydraulicBoundaryData, ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Then + var observables = new List + { + hydraulicBoundaryData.Locations, + assessmentSection.WaterLevelCalculationsForSignalFloodingProbability, + assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability, + assessmentSection.DuneErosion.DuneLocations, + assessmentSection.DuneErosion.DuneLocationCalculationsForUserDefinedTargetProbabilities + }; + + observables.AddRange(assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities + .Select(element => element.HydraulicBoundaryLocationCalculations)); + observables.AddRange(assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities + .Select(element => element.HydraulicBoundaryLocationCalculations)); + observables.AddRange(assessmentSection.DuneErosion.DuneLocationCalculationsForUserDefinedTargetProbabilities + .Select(element => element.DuneLocationCalculations)); + + CollectionAssert.AreEqual(observables, changedObjects); + mocks.VerifyAll(); + } + + [Test] + public void GivenCalculationsWithLocation_WhenUpdatingDatabaseWithNewLocations_ThenCalculationOutputClearedAndChangedObjectsReturned() + { + // Given + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.Stub(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = TestDataGenerator.GetAssessmentSectionWithAllCalculationConfigurations(); + + ICalculation[] calculationsWithOutput = assessmentSection.GetFailureMechanisms() + .OfType() + .SelectMany(fm => fm.Calculations) + .Where(c => c.HasOutput) + .ToArray(); + + calculationsWithOutput = calculationsWithOutput.Except(calculationsWithOutput.OfType() + .Where(c => c.InputParameters.UseAssessmentLevelManualInput)) + .Except(calculationsWithOutput.OfType() + .Where(c => c.InputParameters.UseAssessmentLevelManualInput)) + .Except(calculationsWithOutput.OfType()) + .ToArray(); + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + // When + IEnumerable changedObjects = handler.Update(assessmentSection.HydraulicBoundaryData, ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Then + Assert.IsTrue(calculationsWithOutput.All(c => !c.HasOutput)); + CollectionAssert.IsSubsetOf(calculationsWithOutput, changedObjects); + mocks.VerifyAll(); + } + + [Test] + public void DoPostUpdateActions_NoUpdateCalled_DoNothing() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + mocks.ReplayAll(); + + AssessmentSection assessmentSection = CreateAssessmentSection(); + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + // Call + handler.DoPostUpdateActions(); + + // Assert + mocks.VerifyAll(); + } + + [Test] + public void DoPostUpdateActions_AfterUpdateCalledAndNoLocationsUpdated_DoNothing() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "some/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + ReadHydraulicBoundaryDatabase readHydraulicBoundaryDatabase = ReadHydraulicBoundaryDatabaseTestFactory.Create(); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = hydraulicBoundaryDatabaseFilePath, + Version = readHydraulicBoundaryDatabase.Version, + Locations = + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + } + }; + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + IEnumerable changedObjects = handler.Update(hydraulicBoundaryData, readHydraulicBoundaryDatabase, + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Precondition + CollectionAssert.IsEmpty(changedObjects); + + // Call + handler.DoPostUpdateActions(); + + // Assert + mocks.VerifyAll(); + } + + [Test] + public void DoPostUpdateActions_AfterUpdateCalledAndLocationsUpdated_Perform() + { + // Setup + var mocks = new MockRepository(); + var duneLocationsReplacementHandler = mocks.StrictMock(); + duneLocationsReplacementHandler.Stub(h => h.Replace(null)).IgnoreArguments(); + duneLocationsReplacementHandler.Expect(h => h.DoPostReplacementUpdates()); + mocks.ReplayAll(); + + const string hydraulicBoundaryDatabaseFilePath = "old/file/path"; + const string hlcdFilePath = "some/hlcd/FilePath"; + AssessmentSection assessmentSection = CreateAssessmentSection(); + var hydraulicBoundaryData = new HydraulicBoundaryData + { + FilePath = hydraulicBoundaryDatabaseFilePath, + Version = "1", + Locations = + { + new TestHydraulicBoundaryLocation("old location 1"), + new TestHydraulicBoundaryLocation("old location 2"), + new TestHydraulicBoundaryLocation("old location 3") + } + }; + + var handler = new HydraulicBoundaryDataUpdateHandler(assessmentSection, duneLocationsReplacementHandler); + + IEnumerable changedObjects = handler.Update(hydraulicBoundaryData, ReadHydraulicBoundaryDatabaseTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseTestFactory.Create(), + Enumerable.Empty(), hydraulicBoundaryDatabaseFilePath, hlcdFilePath); + + // Precondition + CollectionAssert.IsNotEmpty(changedObjects); + + // Call + handler.DoPostUpdateActions(); + + // Assert + mocks.VerifyAll(); + } + + private static AssessmentSection CreateAssessmentSection() + { + return new AssessmentSection(AssessmentSectionComposition.Dike); + } + + private static void AssertHydraulicBoundaryLocationsAndCalculations(IEnumerable locations, AssessmentSection assessmentSection) + { + CollectionAssert.AreEqual(locations, assessmentSection.WaterLevelCalculationsForSignalFloodingProbability.Select(hblc => hblc.HydraulicBoundaryLocation)); + CollectionAssert.AreEqual(locations, assessmentSection.WaterLevelCalculationsForMaximumAllowableFloodingProbability.Select(hblc => hblc.HydraulicBoundaryLocation)); + AssertHydraulicBoundaryLocationsOfUserDefinedTargetProbabilities(locations, assessmentSection.WaterLevelCalculationsForUserDefinedTargetProbabilities); + AssertHydraulicBoundaryLocationsOfUserDefinedTargetProbabilities(locations, assessmentSection.WaveHeightCalculationsForUserDefinedTargetProbabilities); + } + + private static void AssertHydraulicBoundaryLocationsOfUserDefinedTargetProbabilities(IEnumerable locations, + IEnumerable targetProbabilities) + { + foreach (HydraulicBoundaryLocationCalculationsForTargetProbability targetProbability in targetProbabilities) + { + CollectionAssert.AreEqual(locations, targetProbability.HydraulicBoundaryLocationCalculations.Select(calc => calc.HydraulicBoundaryLocation)); + } + } + + private static void AssertHydraulicBoundaryLocations(IEnumerable readLocations, + ReadHydraulicLocationConfigurationDatabase readHydraulicLocationConfigurationDatabase, + IEnumerable actualLocations) + { + Assert.AreEqual(readLocations.Count(), actualLocations.Count()); + + for (var i = 0; i < actualLocations.Count(); i++) + { + ReadHydraulicBoundaryLocation readLocation = readLocations.ElementAt(i); + HydraulicBoundaryLocation actualLocation = actualLocations.ElementAt(i); + + Assert.AreEqual(readHydraulicLocationConfigurationDatabase.LocationIdMappings + .Single(l => l.HrdLocationId == readLocation.Id) + .HlcdLocationId, actualLocation.Id); + Assert.AreEqual(readLocation.Name, actualLocation.Name); + Assert.AreEqual(readLocation.CoordinateX, actualLocation.Location.X); + Assert.AreEqual(readLocation.CoordinateY, actualLocation.Location.Y); + } + } + + private static IEnumerable GetInvalidReadHydraulicBoundaryDatabaseConfigurations() + { + yield return new TestCaseData(ReadHydraulicLocationConfigurationDatabaseTestFactory.CreateWithConfigurationSettings( + Enumerable.Empty())) + .SetName("ReadHydraulicLocationConfigurationDatabaseSettingsEmpty"); + yield return new TestCaseData(ReadHydraulicLocationConfigurationDatabaseTestFactory.CreateWithConfigurationSettings( + new[] + { + ReadHydraulicLocationConfigurationDatabaseSettingsTestFactory.Create(), + ReadHydraulicLocationConfigurationDatabaseSettingsTestFactory.Create() + })) + .SetName("ReadHydraulicLocationConfigurationDatabaseSettingsMultipleItems"); + } + } +} \ No newline at end of file Fisheye: Tag d3da87d7d703f1a7b64882c937564f55ae859d96 refers to a dead (removed) revision in file `Riskeer/Integration/test/Riskeer.Integration.Plugin.Test/Handlers/HydraulicBoundaryDatabaseUpdateHandlerTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Riskeer/Integration/test/Riskeer.Integration.TestUtil/DataImportHelper.cs =================================================================== diff -u -r8339953df3276b6c7b4a3d9f5a278e4c19e85be3 -rd3da87d7d703f1a7b64882c937564f55ae859d96 --- Riskeer/Integration/test/Riskeer.Integration.TestUtil/DataImportHelper.cs (.../DataImportHelper.cs) (revision 8339953df3276b6c7b4a3d9f5a278e4c19e85be3) +++ Riskeer/Integration/test/Riskeer.Integration.TestUtil/DataImportHelper.cs (.../DataImportHelper.cs) (revision d3da87d7d703f1a7b64882c937564f55ae859d96) @@ -193,7 +193,7 @@ mocks.ReplayAll(); var hydraulicBoundaryDatabaseImporter = new HydraulicBoundaryDatabaseImporter(assessmentSection.HydraulicBoundaryData, - new HydraulicBoundaryDatabaseUpdateHandler( + new HydraulicBoundaryDataUpdateHandler( assessmentSection, new DuneLocationsReplacementHandler(viewCommands, assessmentSection.DuneErosion)), filePath);