Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/GrassCoverErosionOutwardsCalculationActivityFactory.cs =================================================================== diff -u --- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/GrassCoverErosionOutwardsCalculationActivityFactory.cs (revision 0) +++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/GrassCoverErosionOutwardsCalculationActivityFactory.cs (revision ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd) @@ -0,0 +1,284 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets 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 Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Service; +using Ringtoets.GrassCoverErosionOutwards.Data; +using RingtoetsCommonDataResources = Ringtoets.Common.Data.Properties.Resources; + +namespace Ringtoets.GrassCoverErosionOutwards.Service +{ + /// + /// This class defines factory methods that can be used to create instances of for + /// calculations on grass cover erosion outwards level. + /// + public static class GrassCoverErosionOutwardsCalculationActivityFactory + { + #region Wave Conditions + + /// + /// Creates a collection of based on the calculations in + /// . + /// + /// The failure mechanism containing the calculations to create + /// activities for. + /// The assessment section the belongs to. + /// A collection of . + /// Thrown when any parameter is null. + public static IEnumerable CreateCalculationActivities(GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + return CreateCalculationActivities(failureMechanism.WaveConditionsCalculationGroup, failureMechanism, assessmentSection); + } + + /// + /// Creates a collection of based on the calculations in + /// . + /// + /// The calculation group to create activities for. + /// The failure mechanism the calculations belongs to. + /// The assessment section the calculations in + /// belong to. + /// A collection of . + /// Thrown when any parameter is null. + public static IEnumerable CreateCalculationActivities(CalculationGroup calculationGroup, + GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (calculationGroup == null) + { + throw new ArgumentNullException(nameof(calculationGroup)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + return calculationGroup.GetCalculations() + .Cast() + .Select(calc => CreateCalculationActivity(calc, failureMechanism, assessmentSection)) + .ToArray(); + } + + /// + /// Creates a based on the given . + /// + /// The calculation to create an activity for. + /// The failure mechanism the calculation belongs to. + /// The assessment section the + /// belongs to. + /// A . + /// Thrown when any parameter is null. + public static CalculatableActivity CreateCalculationActivity(GrassCoverErosionOutwardsWaveConditionsCalculation calculation, + GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (calculation == null) + { + throw new ArgumentNullException(nameof(calculation)); + } + + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + return new GrassCoverErosionOutwardsWaveConditionsCalculationActivity(calculation, + assessmentSection.HydraulicBoundaryDatabase.FilePath, + failureMechanism, + assessmentSection); + } + + #endregion + + #region Hydraulic Boundary Location Calculations + + /// + /// Creates a collection of for all hydraulic boundary location calculations + /// on grass cover erosion outwards level. + /// + /// The failure mechanism to create the activities for. + /// The assessment section the failure mechanism belongs to. + /// A collection of . + /// Thrown when any parameter is null. + public static IEnumerable CreateHydraulicBoundaryLocationCalculationActivities( + GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + var activities = new List(); + activities.AddRange(CreateDesignWaterLevelCalculationActivities(failureMechanism, assessmentSection)); + activities.AddRange(CreateWaveHeightCalculationActivities(failureMechanism, assessmentSection)); + return activities; + } + + /// + /// Creates a collection of for wave height calculations + /// on grass cover erosion outwards level. + /// + /// The failure mechanism to create the activities for. + /// The assessment section the failure mechanism belongs to. + /// A collection of . + /// Thrown when any parameter is null. + public static IEnumerable CreateWaveHeightCalculationActivities( + GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + var activities = new List(); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateWaveHeightCalculationActivities( + failureMechanism.WaveHeightCalculationsForMechanismSpecificFactorizedSignalingNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificFactorizedSignalingNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateWaveHeightCalculationActivities( + failureMechanism.WaveHeightCalculationsForMechanismSpecificSignalingNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificSignalingNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificSignalingNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateWaveHeightCalculationActivities( + failureMechanism.WaveHeightCalculationsForMechanismSpecificLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificLowerLimitNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateWaveHeightCalculationActivities( + assessmentSection.WaveHeightCalculationsForLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.LowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_LowerLimitNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateWaveHeightCalculationActivities( + assessmentSection.WaveHeightCalculationsForFactorizedLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.FactorizedLowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_FactorizedLowerLimitNorm_DisplayName)); + + return activities; + } + + /// + /// Creates a collection of for design water level calculations + /// on grass cover erosion outwards level. + /// + /// The failure mechanism to create the activities for. + /// The assessment section the failure mechanism belongs to. + /// A collection of . + /// Thrown when any parameter is null. + public static IEnumerable CreateDesignWaterLevelCalculationActivities( + GrassCoverErosionOutwardsFailureMechanism failureMechanism, + IAssessmentSection assessmentSection) + { + if (failureMechanism == null) + { + throw new ArgumentNullException(nameof(failureMechanism)); + } + + if (assessmentSection == null) + { + throw new ArgumentNullException(nameof(assessmentSection)); + } + + var activities = new List(); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + failureMechanism.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificFactorizedSignalingNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + failureMechanism.WaterLevelCalculationsForMechanismSpecificSignalingNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificSignalingNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificSignalingNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + failureMechanism.WaterLevelCalculationsForMechanismSpecificLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.MechanismSpecificLowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_MechanismSpecificLowerLimitNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + assessmentSection.WaterLevelCalculationsForLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.LowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_LowerLimitNorm_DisplayName)); + + activities.AddRange(HydraulicBoundaryLocationCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + assessmentSection.WaterLevelCalculationsForFactorizedLowerLimitNorm, + assessmentSection, + failureMechanism.GetNorm(assessmentSection, FailureMechanismCategoryType.FactorizedLowerLimitNorm), + RingtoetsCommonDataResources.FailureMechanismCategoryType_FactorizedLowerLimitNorm_DisplayName)); + + return activities; + } + + #endregion + } +} \ No newline at end of file Fisheye: Tag ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd refers to a dead (removed) revision in file `Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/GrassCoverErosionOutwardsHydraulicBoundaryLocationCalculationActivityFactory.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/Ringtoets.GrassCoverErosionOutwards.Service.csproj =================================================================== diff -u -rad6ea4a264708e1e54660bdd7e14b5393911cfb1 -ree8c255422bc22eb2ff31b77c38fcd6175b5cfdd --- Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/Ringtoets.GrassCoverErosionOutwards.Service.csproj (.../Ringtoets.GrassCoverErosionOutwards.Service.csproj) (revision ad6ea4a264708e1e54660bdd7e14b5393911cfb1) +++ Ringtoets/GrassCoverErosionOutwards/src/Ringtoets.GrassCoverErosionOutwards.Service/Ringtoets.GrassCoverErosionOutwards.Service.csproj (.../Ringtoets.GrassCoverErosionOutwards.Service.csproj) (revision ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd) @@ -11,7 +11,7 @@ - + Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/GrassCoverErosionOutwardsCalculationActivityFactoryTest.cs =================================================================== diff -u --- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/GrassCoverErosionOutwardsCalculationActivityFactoryTest.cs (revision 0) +++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/GrassCoverErosionOutwardsCalculationActivityFactoryTest.cs (revision ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd) @@ -0,0 +1,843 @@ +// Copyright (C) Stichting Deltares 2017. All rights reserved. +// +// This file is part of Ringtoets. +// +// Ringtoets 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.IO; +using System.Linq; +using Core.Common.Base.Data; +using Core.Common.Base.Service; +using Core.Common.TestUtil; +using Core.Common.Util; +using NUnit.Framework; +using Rhino.Mocks; +using Ringtoets.Common.Data.AssessmentSection; +using Ringtoets.Common.Data.Calculation; +using Ringtoets.Common.Data.FailureMechanism; +using Ringtoets.Common.Data.Hydraulics; +using Ringtoets.Common.Data.TestUtil; +using Ringtoets.Common.Service; +using Ringtoets.Common.Service.TestUtil; +using Ringtoets.GrassCoverErosionOutwards.Data; +using Ringtoets.HydraRing.Calculation.Calculator.Factory; +using Ringtoets.HydraRing.Calculation.Data.Input.Hydraulics; +using Ringtoets.HydraRing.Calculation.Data.Input.WaveConditions; +using Ringtoets.HydraRing.Calculation.TestUtil.Calculator; + +namespace Ringtoets.GrassCoverErosionOutwards.Service.Test +{ + [TestFixture] + public class GrassCoverErosionOutwardsCalculationActivityFactoryTest + { + private static readonly string testDataPath = TestHelper.GetTestDataPath(TestDataPath.Ringtoets.Integration.Service, "HydraRingCalculation"); + private static readonly string validFilePath = Path.Combine(testDataPath, "HRD ijsselmeer.sqlite"); + private static readonly string validPreprocessorDirectory = TestHelper.GetScratchPadPath(); + + private static GrassCoverErosionOutwardsFailureMechanism CreateFailureMechanism() + { + return new GrassCoverErosionOutwardsFailureMechanism + { + Contribution = 10 + }; + } + + #region Wave Conditions + + [Test] + public void CreateCalculationActivity_CalculationNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivity(null, + new GrassCoverErosionOutwardsFailureMechanism(), + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("calculation", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivity_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivity(new GrassCoverErosionOutwardsWaveConditionsCalculation(), + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivity_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Setup + var calculation = new GrassCoverErosionOutwardsWaveConditionsCalculation(); + var failureMechanism = new GrassCoverErosionOutwardsFailureMechanism(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivity(calculation, failureMechanism, null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void CreateCalculationActivity_WithValidCalculation_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivityWithParametersSet() + { + // Setup + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mocks, + validFilePath); + + mocks.ReplayAll(); + + var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); + GrassCoverErosionOutwardsWaveConditionsCalculation calculation = CreateValidCalculation(hydraulicBoundaryLocation); + + AddHydraulicBoundaryLocationToFailureMechanism(failureMechanism, hydraulicBoundaryLocation); + + // Call + CalculatableActivity activity = GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivity(calculation, + failureMechanism, + assessmentSection); + + // Assert + Assert.IsInstanceOf(activity); + AssertGrassCoverErosionOutwardsCalculationActivity(activity, calculation); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivitiesForCalculationGroup_CalculationGroupNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities(null, + new GrassCoverErosionOutwardsFailureMechanism(), + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("calculationGroup", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivitiesForCalculationGroup_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities(new CalculationGroup(), + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivitiesForCalculationGroup_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities(new CalculationGroup(), + new GrassCoverErosionOutwardsFailureMechanism(), + null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void CreateCalculationActivitiesForCalculationGroup_WithValidCalculations_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivitiesWithParametersSet() + { + // Setup + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mocks, + validFilePath); + + mocks.ReplayAll(); + + var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); + GrassCoverErosionOutwardsWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); + GrassCoverErosionOutwardsWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); + + AddHydraulicBoundaryLocationToFailureMechanism(failureMechanism, hydraulicBoundaryLocation); + + var calculations = new CalculationGroup + { + Children = + { + calculation1, + calculation2 + } + }; + + // Call + IEnumerable activities = GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities( + calculations, failureMechanism, assessmentSection); + + // Assert + CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionOutwardsWaveConditionsCalculationActivity)); + Assert.AreEqual(2, activities.Count()); + + AssertGrassCoverErosionOutwardsCalculationActivity(activities.First(), calculation1); + AssertGrassCoverErosionOutwardsCalculationActivity(activities.ElementAt(1), calculation2); + mocks.VerifyAll(); + } + + private static void AddHydraulicBoundaryLocationToFailureMechanism(GrassCoverErosionOutwardsFailureMechanism failureMechanism, + TestHydraulicBoundaryLocation hydraulicBoundaryLocation) + { + failureMechanism.SetHydraulicBoundaryLocationCalculations(new[] + { + hydraulicBoundaryLocation + }); + failureMechanism.WaterLevelCalculationsForMechanismSpecificFactorizedSignalingNorm.Single().Output = new TestHydraulicBoundaryLocationCalculationOutput(2.0); + } + + [Test] + public void CreateCalculationActivitiesForFailureMechanism_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities(null, assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateCalculationActivitiesForFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities(new GrassCoverErosionOutwardsFailureMechanism(), null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsGrassCoverErosionOutwardsWaveConditionsCalculationActivitiesWithParametersSet() + { + // Setup + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var mocks = new MockRepository(); + IAssessmentSection assessmentSection = AssessmentSectionHelper.CreateAssessmentSectionStub(failureMechanism, + mocks, + validFilePath); + + mocks.ReplayAll(); + + var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation(); + GrassCoverErosionOutwardsWaveConditionsCalculation calculation1 = CreateValidCalculation(hydraulicBoundaryLocation); + GrassCoverErosionOutwardsWaveConditionsCalculation calculation2 = CreateValidCalculation(hydraulicBoundaryLocation); + + AddHydraulicBoundaryLocationToFailureMechanism(failureMechanism, hydraulicBoundaryLocation); + + failureMechanism.WaveConditionsCalculationGroup.Children.AddRange(new[] + { + calculation1, + calculation2 + }); + + // Call + IEnumerable activities = GrassCoverErosionOutwardsCalculationActivityFactory.CreateCalculationActivities( + failureMechanism, assessmentSection); + + // Assert + CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionOutwardsWaveConditionsCalculationActivity)); + Assert.AreEqual(2, activities.Count()); + + AssertGrassCoverErosionOutwardsCalculationActivity(activities.First(), calculation1); + AssertGrassCoverErosionOutwardsCalculationActivity(activities.ElementAt(1), calculation2); + mocks.VerifyAll(); + } + + private static GrassCoverErosionOutwardsWaveConditionsCalculation CreateValidCalculation(HydraulicBoundaryLocation hydraulicBoundaryLocation) + { + return new GrassCoverErosionOutwardsWaveConditionsCalculation + { + InputParameters = + { + HydraulicBoundaryLocation = hydraulicBoundaryLocation, + CategoryType = FailureMechanismCategoryType.MechanismSpecificFactorizedSignalingNorm, + ForeshoreProfile = new TestForeshoreProfile(true) + { + BreakWater = + { + Height = new Random(39).NextRoundedDouble() + } + }, + UseForeshore = true, + UseBreakWater = true, + LowerBoundaryRevetment = (RoundedDouble) 1, + UpperBoundaryRevetment = (RoundedDouble) 3, + LowerBoundaryWaterLevels = (RoundedDouble) 1, + UpperBoundaryWaterLevels = (RoundedDouble) 3 + } + }; + } + + private static void AssertGrassCoverErosionOutwardsCalculationActivity(Activity activity, + GrassCoverErosionOutwardsWaveConditionsCalculation calculation) + { + var mocks = new MockRepository(); + var testCalculator = new TestWaveConditionsCosineCalculator(); + var calculatorFactory = mocks.StrictMock(); + calculatorFactory.Expect(cf => cf.CreateWaveConditionsCosineCalculator(testDataPath, "")) + .Return(testCalculator).Repeat.Times(3); + mocks.ReplayAll(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + activity.Run(); + + Assert.AreEqual(3, testCalculator.ReceivedInputs.Count); + foreach (WaveConditionsCosineCalculationInput input in testCalculator.ReceivedInputs) + { + Assert.AreEqual(calculation.InputParameters.BreakWater.Height, input.BreakWater.Height); + } + } + + mocks.VerifyAll(); + } + + #endregion + + #region Hydraulic Boundary Location Calculations + + [Test] + public void CreateHydraulicBoundaryLocationCalculationActivities_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateHydraulicBoundaryLocationCalculationActivities( + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateHydraulicBoundaryLocationCalculationActivities_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateHydraulicBoundaryLocationCalculationActivities( + new GrassCoverErosionOutwardsFailureMechanism(), + null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void CreateHydraulicBoundaryLocationCalculationActivities_WithValidDataAndUsePreprocessorStates_ExpectedInputSetToActivities(bool usePreprocessor) + { + // Setup + AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor); + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation("locationName 1"); + TestHydraulicBoundaryLocation[] hydraulicBoundaryLocations = + { + hydraulicBoundaryLocation + }; + + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + failureMechanism.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + + // Call + IEnumerable activities = + GrassCoverErosionOutwardsCalculationActivityFactory.CreateHydraulicBoundaryLocationCalculationActivities( + failureMechanism, + assessmentSection); + + // Assert + Assert.AreEqual(10, activities.Count()); + + double mechanismSpecificFactorizedSignalingNorm = GetExpectedNorm(failureMechanism, + () => assessmentSection.FailureMechanismContribution.SignalingNorm / 30); + double mechanismSpecificSignalingNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.SignalingNorm); + double mechanismSpecificLowerLimitNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.LowerLimitNorm); + double lowerLimitNorm = assessmentSection.FailureMechanismContribution.LowerLimitNorm; + double factorizedLowerLimitNorm = lowerLimitNorm * 30; + + AssertDesignWaterLevelCalculationActivity(activities.First(), + hydraulicBoundaryLocation, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(1), + hydraulicBoundaryLocation, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(2), + hydraulicBoundaryLocation, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(3), + hydraulicBoundaryLocation, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(4), + hydraulicBoundaryLocation, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + + AssertWaveHeightCalculationActivity(activities.ElementAt(5), + hydraulicBoundaryLocation, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(6), + hydraulicBoundaryLocation, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + + AssertWaveHeightCalculationActivity(activities.ElementAt(7), + hydraulicBoundaryLocation, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(8), + hydraulicBoundaryLocation, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(9), + hydraulicBoundaryLocation, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + } + + [Test] + public void CreateDesignWaterLevelCalculationActivities_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateDesignWaterLevelCalculationActivities_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + new GrassCoverErosionOutwardsFailureMechanism(), + null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void CreateDesignWaterLevelCalculationActivities_WithValidDataAndUsePreprocessorStates_ExpectedInputSetToActivities(bool usePreprocessor) + { + // Setup + AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor); + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation("locationName 1"); + var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation("locationName 2"); + TestHydraulicBoundaryLocation[] hydraulicBoundaryLocations = + { + hydraulicBoundaryLocation1, + hydraulicBoundaryLocation2 + }; + + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + failureMechanism.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + + // Call + IEnumerable activities = + GrassCoverErosionOutwardsCalculationActivityFactory.CreateDesignWaterLevelCalculationActivities( + failureMechanism, + assessmentSection); + + // Assert + Assert.AreEqual(10, activities.Count()); + + double mechanismSpecificFactorizedSignalingNorm = GetExpectedNorm(failureMechanism, + () => assessmentSection.FailureMechanismContribution.SignalingNorm / 30); + AssertDesignWaterLevelCalculationActivity(activities.First(), + hydraulicBoundaryLocation1, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(1), + hydraulicBoundaryLocation2, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + + double mechanismSpecificSignalingNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.SignalingNorm); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(2), + hydraulicBoundaryLocation1, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(3), + hydraulicBoundaryLocation2, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + + double mechanismSpecificLowerLimitNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.LowerLimitNorm); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(4), + hydraulicBoundaryLocation1, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(5), + hydraulicBoundaryLocation2, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + + double lowerLimitNorm = assessmentSection.FailureMechanismContribution.LowerLimitNorm; + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(6), + hydraulicBoundaryLocation1, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(7), + hydraulicBoundaryLocation2, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + + double factorizedLowerLimitNorm = lowerLimitNorm * 30; + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(8), + hydraulicBoundaryLocation1, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + AssertDesignWaterLevelCalculationActivity(activities.ElementAt(9), + hydraulicBoundaryLocation2, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + } + + [Test] + public void CreateWaveHeightCalculationActivities_FailureMechanismNull_ThrowsArgumentNullException() + { + // Setup + var mocks = new MockRepository(); + var assessmentSection = mocks.Stub(); + mocks.ReplayAll(); + + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveHeightCalculationActivities( + null, + assessmentSection); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("failureMechanism", exception.ParamName); + mocks.VerifyAll(); + } + + [Test] + public void CreateWaveHeightCalculationActivities_AssessmentSectionNull_ThrowsArgumentNullException() + { + // Call + TestDelegate test = () => + GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveHeightCalculationActivities( + new GrassCoverErosionOutwardsFailureMechanism(), + null); + + // Assert + var exception = Assert.Throws(test); + Assert.AreEqual("assessmentSection", exception.ParamName); + } + + [Test] + [TestCase(true)] + [TestCase(false)] + public void CreateWaveHeightCalculationActivities_WithValidDataAndUsePreprocessorStates_ExpectedInputSetToActivities(bool usePreprocessor) + { + // Setup + AssessmentSectionStub assessmentSection = CreateAssessmentSection(usePreprocessor); + GrassCoverErosionOutwardsFailureMechanism failureMechanism = CreateFailureMechanism(); + + var hydraulicBoundaryLocation1 = new TestHydraulicBoundaryLocation("locationName 1"); + var hydraulicBoundaryLocation2 = new TestHydraulicBoundaryLocation("locationName 2"); + TestHydraulicBoundaryLocation[] hydraulicBoundaryLocations = + { + hydraulicBoundaryLocation1, + hydraulicBoundaryLocation2 + }; + + assessmentSection.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + failureMechanism.SetHydraulicBoundaryLocationCalculations(hydraulicBoundaryLocations); + + // Call + IEnumerable activities = + GrassCoverErosionOutwardsCalculationActivityFactory.CreateWaveHeightCalculationActivities( + failureMechanism, + assessmentSection); + + // Assert + Assert.AreEqual(10, activities.Count()); + + double mechanismSpecificFactorizedSignalingNorm = GetExpectedNorm(failureMechanism, + () => assessmentSection.FailureMechanismContribution.SignalingNorm / 30); + AssertWaveHeightCalculationActivity(activities.First(), + hydraulicBoundaryLocation1, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(1), + hydraulicBoundaryLocation2, + mechanismSpecificFactorizedSignalingNorm, + "Iv->IIv", + usePreprocessor); + + double mechanismSpecificSignalingNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.SignalingNorm); + AssertWaveHeightCalculationActivity(activities.ElementAt(2), + hydraulicBoundaryLocation1, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(3), + hydraulicBoundaryLocation2, + mechanismSpecificSignalingNorm, + "IIv->IIIv", + usePreprocessor); + + double mechanismSpecificLowerLimitNorm = GetExpectedNorm(failureMechanism, () => assessmentSection.FailureMechanismContribution.LowerLimitNorm); + AssertWaveHeightCalculationActivity(activities.ElementAt(4), + hydraulicBoundaryLocation1, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(5), + hydraulicBoundaryLocation2, + mechanismSpecificLowerLimitNorm, + "IIIv->IVv", + usePreprocessor); + + double lowerLimitNorm = assessmentSection.FailureMechanismContribution.LowerLimitNorm; + AssertWaveHeightCalculationActivity(activities.ElementAt(6), + hydraulicBoundaryLocation1, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(7), + hydraulicBoundaryLocation2, + lowerLimitNorm, + "IVv->Vv", + usePreprocessor); + + double factorizedLowerLimitNorm = lowerLimitNorm * 30; + AssertWaveHeightCalculationActivity(activities.ElementAt(8), + hydraulicBoundaryLocation1, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + AssertWaveHeightCalculationActivity(activities.ElementAt(9), + hydraulicBoundaryLocation2, + factorizedLowerLimitNorm, + "Vv->VIv", + usePreprocessor); + } + + private static AssessmentSectionStub CreateAssessmentSection(bool usePreprocessor) + { + var assessmentSection = new AssessmentSectionStub(); + + assessmentSection.HydraulicBoundaryDatabase.CanUsePreprocessor = true; + assessmentSection.HydraulicBoundaryDatabase.UsePreprocessor = usePreprocessor; + assessmentSection.HydraulicBoundaryDatabase.FilePath = validFilePath; + assessmentSection.HydraulicBoundaryDatabase.PreprocessorDirectory = validPreprocessorDirectory; + + return assessmentSection; + } + + private static void AssertDesignWaterLevelCalculationActivity(Activity activity, + HydraulicBoundaryLocation hydraulicBoundaryLocation, + double norm, + string categoryBoundaryName, + bool usePreprocessor) + { + var mocks = new MockRepository(); + var designWaterLevelCalculator = new TestDesignWaterLevelCalculator(); + var calculatorFactory = mocks.Stub(); + calculatorFactory.Expect(cf => cf.CreateDesignWaterLevelCalculator(testDataPath, usePreprocessor ? validPreprocessorDirectory : "")).Return(designWaterLevelCalculator); + mocks.ReplayAll(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + Action call = activity.Run; + + TestHelper.AssertLogMessages(call, m => + { + string[] messages = m.ToArray(); + AssertHydraulicBoundaryLocationCalculationMessages(hydraulicBoundaryLocation, + messages, + "Waterstand", + categoryBoundaryName); + }); + + AssessmentLevelCalculationInput actualCalculationInput = designWaterLevelCalculator.ReceivedInputs.Single(); + Assert.AreEqual(hydraulicBoundaryLocation.Id, actualCalculationInput.HydraulicBoundaryLocationId); + Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), actualCalculationInput.Beta); + } + + mocks.VerifyAll(); + } + + private static void AssertWaveHeightCalculationActivity(Activity activity, + HydraulicBoundaryLocation hydraulicBoundaryLocation, + double norm, + string categoryBoundaryName, + bool usePreprocessor) + { + var mocks = new MockRepository(); + var waveHeightCalculator = new TestWaveHeightCalculator(); + var calculatorFactory = mocks.Stub(); + calculatorFactory.Expect(cf => cf.CreateWaveHeightCalculator(testDataPath, usePreprocessor ? validPreprocessorDirectory : "")).Return(waveHeightCalculator); + mocks.ReplayAll(); + + using (new HydraRingCalculatorFactoryConfig(calculatorFactory)) + { + Action call = activity.Run; + + TestHelper.AssertLogMessages(call, m => + { + string[] messages = m.ToArray(); + AssertHydraulicBoundaryLocationCalculationMessages(hydraulicBoundaryLocation, + messages, + "Golfhoogte", + categoryBoundaryName); + }); + + WaveHeightCalculationInput actualCalculationInput = waveHeightCalculator.ReceivedInputs.Single(); + Assert.AreEqual(hydraulicBoundaryLocation.Id, actualCalculationInput.HydraulicBoundaryLocationId); + Assert.AreEqual(StatisticsConverter.ProbabilityToReliability(norm), actualCalculationInput.Beta); + } + + mocks.VerifyAll(); + } + + private static void AssertHydraulicBoundaryLocationCalculationMessages(HydraulicBoundaryLocation hydraulicBoundaryLocation, + IEnumerable messages, + string calculationTypeName, + string categoryBoundaryName) + { + Assert.AreEqual(7, messages.Count()); + Assert.AreEqual($"{calculationTypeName} berekenen voor locatie '{hydraulicBoundaryLocation.Name}' (Categorie {categoryBoundaryName}) is gestart.", messages.First()); + CalculationServiceTestHelper.AssertValidationStartMessage(messages.ElementAt(1)); + CalculationServiceTestHelper.AssertValidationEndMessage(messages.ElementAt(2)); + CalculationServiceTestHelper.AssertCalculationStartMessage(messages.ElementAt(3)); + Assert.AreEqual($"{calculationTypeName} berekening voor locatie '{hydraulicBoundaryLocation.Name}' (Categorie {categoryBoundaryName}) is niet geconvergeerd.", messages.ElementAt(4)); + StringAssert.StartsWith($"{calculationTypeName} berekening is uitgevoerd op de tijdelijke locatie", messages.ElementAt(5)); + CalculationServiceTestHelper.AssertCalculationEndMessage(messages.ElementAt(6)); + } + + private static double GetExpectedNorm(GrassCoverErosionOutwardsFailureMechanism failureMechanism, Func getNormFunc) + { + return RingtoetsCommonDataCalculationService.ProfileSpecificRequiredProbability( + getNormFunc(), + failureMechanism.Contribution, + failureMechanism.GeneralInput.N); + } + + #endregion + } +} \ No newline at end of file Fisheye: Tag ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd refers to a dead (removed) revision in file `Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/GrassCoverErosionOutwardsHydraulicBoundaryLocationCalculationActivityFactoryTest.cs'. Fisheye: No comparison available. Pass `N' to diff? Index: Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/Ringtoets.GrassCoverErosionOutwards.Service.Test.csproj =================================================================== diff -u -rad6ea4a264708e1e54660bdd7e14b5393911cfb1 -ree8c255422bc22eb2ff31b77c38fcd6175b5cfdd --- Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/Ringtoets.GrassCoverErosionOutwards.Service.Test.csproj (.../Ringtoets.GrassCoverErosionOutwards.Service.Test.csproj) (revision ad6ea4a264708e1e54660bdd7e14b5393911cfb1) +++ Ringtoets/GrassCoverErosionOutwards/test/Ringtoets.GrassCoverErosionOutwards.Service.Test/Ringtoets.GrassCoverErosionOutwards.Service.Test.csproj (.../Ringtoets.GrassCoverErosionOutwards.Service.Test.csproj) (revision ee8c255422bc22eb2ff31b77c38fcd6175b5cfdd) @@ -19,7 +19,7 @@ - +