Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs =================================================================== diff -u -r01ff2c58c13df8f42661ae3e446dc2caaa94247e -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision 01ff2c58c13df8f42661ae3e446dc2caaa94247e) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/CalculationGroupCreateExtensions.cs (.../CalculationGroupCreateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -21,10 +21,12 @@ using System; +using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Create.Piping; using Application.Ringtoets.Storage.DbContext; using Ringtoets.Common.Data.Calculation; +using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.Piping.Data; namespace Application.Ringtoets.Storage.Create @@ -77,6 +79,11 @@ { entity.PipingCalculationEntities.Add(childPipingCalculation.Create(registry, i)); } + var childGrassCoverErosionInwardsCalculation = calculationBase as GrassCoverErosionInwardsCalculation; + if (childGrassCoverErosionInwardsCalculation != null) + { + entity.GrassCoverErosionInwardsCalculationEntities.Add(childGrassCoverErosionInwardsCalculation.Create(registry, i)); + } } } } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Create/GrassCoverErosionInwards/GrassCoverErosionInwardsCalculationCreateExtensions.cs =================================================================== diff -u -r5da102ed42420b0272dfd2ecdd5aaa3a9ebd251c -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Create/GrassCoverErosionInwards/GrassCoverErosionInwardsCalculationCreateExtensions.cs (.../GrassCoverErosionInwardsCalculationCreateExtensions.cs) (revision 5da102ed42420b0272dfd2ecdd5aaa3a9ebd251c) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Create/GrassCoverErosionInwards/GrassCoverErosionInwardsCalculationCreateExtensions.cs (.../GrassCoverErosionInwardsCalculationCreateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -39,6 +39,8 @@ /// /// The calculation to create a database entity for. /// The object keeping track of create operations. + /// The index at where resides + /// in its parent container. /// A new . /// Thrown when is null. internal static GrassCoverErosionInwardsCalculationEntity Create(this GrassCoverErosionInwardsCalculation calculation, PersistenceRegistry registry, int order) Index: Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/DatabaseStructure.sql =================================================================== diff -u -raf68f7b3b97670d3cf5eba6d4cdf2da993ec0f2b -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/DatabaseStructure.sql (.../DatabaseStructure.sql) (revision af68f7b3b97670d3cf5eba6d4cdf2da993ec0f2b) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/DatabaseStructure.sql (.../DatabaseStructure.sql) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -295,8 +295,7 @@ 'BreakWaterType' SMALLINT NOT NULL, 'BreakWaterHeight' NUMERIC NOT NULL, CONSTRAINT 'FK_GrassCoverErosionInwardsCalculationEntity_CalculationGroupEntity' FOREIGN KEY ('CalculationGroupEntityId') REFERENCES 'CalculationGroupEntity' ('CalculationGroupEntityId') ON DELETE Cascade ON UPDATE Cascade, - CONSTRAINT 'FK_GrassCoverErosionInwardsCalculationEntity_HydraulicLocationEntity' FOREIGN KEY ('HydraulicLocationEntityId') REFERENCES 'HydraulicLocationEntity' ('HydraulicLocationEntityId') ON DELETE Set Null ON UPDATE Cascade, - CONSTRAINT 'FK_GrassCoverErosionInwardsCalculationEntity_ProbabilisticOutputEntity' FOREIGN KEY ('ProbabilisticOutputEntityId') REFERENCES 'ProbabilisticOutputEntity' ('ProbabilisticOutputEntityId') ON DELETE Set Null ON UPDATE Cascade + CONSTRAINT 'FK_GrassCoverErosionInwardsCalculationEntity_HydraulicLocationEntity' FOREIGN KEY ('HydraulicLocationEntityId') REFERENCES 'HydraulicLocationEntity' ('HydraulicLocationEntityId') ON DELETE Set Null ON UPDATE Cascade ) ; @@ -711,10 +710,6 @@ ON 'GrassCoverErosionInwardsCalculationEntity' ('HydraulicLocationEntityId' ASC) ; -CREATE INDEX 'IXFK_GrassCoverErosionInwardsCalculationEntity_ProbabilisticOutputEntity' - ON 'GrassCoverErosionInwardsCalculationEntity' ('ProbabilisticOutputEntityId' ASC) -; - CREATE INDEX 'IXFK_ReferenceLinePointEntity_AssessmentSectionEntity' ON 'ReferenceLinePointEntity' ('AssessmentSectionEntityId' ASC) ; Index: Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx =================================================================== diff -u -r293206f556097f4aa2b3da952ce5dcff8b60210a -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx (.../RingtoetsEntities.edmx) (revision 293206f556097f4aa2b3da952ce5dcff8b60210a) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx (.../RingtoetsEntities.edmx) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -585,7 +585,7 @@ - + @@ -597,7 +597,7 @@ - + @@ -1088,11 +1088,11 @@ - + - + @@ -1300,7 +1300,7 @@ - + @@ -1412,7 +1412,7 @@ - + @@ -1487,7 +1487,7 @@ - + @@ -1615,8 +1615,8 @@ - - + + @@ -1692,7 +1692,7 @@ - + @@ -2079,7 +2079,7 @@ - + @@ -2415,7 +2415,7 @@ - + Index: Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx.diagram =================================================================== diff -u -raf68f7b3b97670d3cf5eba6d4cdf2da993ec0f2b -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx.diagram (.../RingtoetsEntities.edmx.diagram) (revision af68f7b3b97670d3cf5eba6d4cdf2da993ec0f2b) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/DbContext/RingtoetsEntities.edmx.diagram (.../RingtoetsEntities.edmx.diagram) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -6,54 +6,54 @@ - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - - - - - - - + + + + + + + + + + + + - - + + - + @@ -81,7 +81,7 @@ - + Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs =================================================================== diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision a5714fc0488030773fff50dfc82041c6cb9edc2f) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Read/CalculationGroupEntityReadExtentions.cs (.../CalculationGroupEntityReadExtentions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -23,6 +23,7 @@ using System.Collections; using Application.Ringtoets.Storage.DbContext; +using Application.Ringtoets.Storage.Read.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Read.Piping; using Ringtoets.Common.Data.Calculation; @@ -71,10 +72,10 @@ { group.Children.Add(childCalculationGroupEntity.ReadPipingCalculationGroup(collector, generalPipingInput)); } - var childPipingCalculationEntity = childEntity as PipingCalculationEntity; - if (childPipingCalculationEntity != null) + var childCalculationEntity = childEntity as PipingCalculationEntity; + if (childCalculationEntity != null) { - group.Children.Add(childPipingCalculationEntity.Read(collector, generalPipingInput)); + group.Children.Add(childCalculationEntity.Read(collector, generalPipingInput)); } } @@ -110,11 +111,10 @@ { group.Children.Add(childCalculationGroupEntity.ReadAsGrassCoverErosionInwardsCalculationGroup(collector)); } - var childPipingCalculationEntity = childEntity as GrassCoverErosionInwardsCalculationEntity; - if (childPipingCalculationEntity != null) + var childCalculationEntity = childEntity as GrassCoverErosionInwardsCalculationEntity; + if (childCalculationEntity != null) { - // TODO - //group.Children.Add(childPipingCalculationEntity.Read(collector, generalPipingInput)); + group.Children.Add(childCalculationEntity.Read()); } } @@ -132,7 +132,10 @@ { sortedList.Add(pipingCalculationEntity.Order, pipingCalculationEntity); } - //TODO Grass Cover Erosion Inwards Calculations + foreach (GrassCoverErosionInwardsCalculationEntity grassCoverErosionInwardsCalculationEntity in entity.GrassCoverErosionInwardsCalculationEntities) + { + sortedList.Add(grassCoverErosionInwardsCalculationEntity.Order, grassCoverErosionInwardsCalculationEntity); + } return sortedList.Values; } } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs =================================================================== diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs (.../CalculationGroupUpdateExtensions.cs) (revision a5714fc0488030773fff50dfc82041c6cb9edc2f) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/CalculationGroupUpdateExtensions.cs (.../CalculationGroupUpdateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -23,14 +23,18 @@ using System.Linq; using Application.Ringtoets.Storage.Create; +using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards; using Application.Ringtoets.Storage.Create.Piping; using Application.Ringtoets.Storage.DbContext; using Application.Ringtoets.Storage.Exceptions; using Application.Ringtoets.Storage.Update.Piping; using Ringtoets.Common.Data.Calculation; +using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.Piping.Data; +using Application.Ringtoets.Storage.Update.GrassCoverErosionInwards; + namespace Application.Ringtoets.Storage.Update { /// @@ -45,14 +49,16 @@ /// The calculation group to update the database entity for. /// The object keeping track of update operations. /// The context to obtain the existing entity from. + /// The index at which resides + /// in the parent container. /// Thrown when either: /// /// is null /// is null /// /// When /// does not have a corresponding entity in the database. - internal static void Update(this CalculationGroup calculationGroup, PersistenceRegistry registry, IRingtoetsEntities context) + internal static void Update(this CalculationGroup calculationGroup, PersistenceRegistry registry, IRingtoetsEntities context, int order) { if (registry == null) { @@ -65,6 +71,7 @@ CalculationGroupEntity entity = calculationGroup.GetCorrespondingEntity(context.CalculationGroupEntities, o => o.CalculationGroupEntityId); entity.Name = calculationGroup.Name; + entity.Order = order; UpdateChildren(entity, calculationGroup, registry, context); @@ -76,44 +83,88 @@ for (int i = 0; i < calculationGroup.Children.Count; i++) { ICalculationBase calculationBase = calculationGroup.Children[i]; - var childGroup = calculationBase as CalculationGroup; - if (childGroup != null) + UpdateIfCalculationGroup(entity, registry, context, calculationBase, i); + + UpdateIfPipingCalculation(entity, registry, context, calculationBase, i); + + UpdateIfGrassCoverErosionInwardsCalculation(entity, registry, context, calculationBase, i); + } + } + + private static void UpdateIfCalculationGroup(CalculationGroupEntity entity, + PersistenceRegistry registry, + IRingtoetsEntities context, + ICalculationBase calculationBase, + int order) + { + var childGroup = calculationBase as CalculationGroup; + if (childGroup != null) + { + if (childGroup.IsNew()) { - if (childGroup.IsNew()) + entity.CalculationGroupEntity1.Add(childGroup.Create(registry, order)); + } + else + { + childGroup.Update(registry, context, order); + CalculationGroupEntity childGroupEntity = context.CalculationGroupEntities.First(cge => cge.CalculationGroupEntityId == childGroup.StorageId); + if (!entity.CalculationGroupEntity1.Contains(childGroupEntity)) { - entity.CalculationGroupEntity1.Add(childGroup.Create(registry, i)); + childGroupEntity.CalculationGroupEntity2.CalculationGroupEntity1.Remove(childGroupEntity); + entity.CalculationGroupEntity1.Add(childGroupEntity); } - else + } + } + } + + private static void UpdateIfPipingCalculation(CalculationGroupEntity entity, + PersistenceRegistry registry, + IRingtoetsEntities context, + ICalculationBase calculationBase, + int order) + { + var childCalculation = calculationBase as PipingCalculationScenario; + if (childCalculation != null) + { + if (childCalculation.IsNew()) + { + entity.PipingCalculationEntities.Add(childCalculation.Create(registry, order)); + } + else + { + childCalculation.Update(registry, context, order); + PipingCalculationEntity childCalculationEntity = context.PipingCalculationEntities.First(cge => cge.PipingCalculationEntityId == childCalculation.StorageId); + if (!entity.PipingCalculationEntities.Contains(childCalculationEntity)) { - childGroup.Update(registry, context); - CalculationGroupEntity childGroupEntity = context.CalculationGroupEntities.First(cge => cge.CalculationGroupEntityId == childGroup.StorageId); - childGroupEntity.Order = i; - if (!entity.CalculationGroupEntity1.Contains(childGroupEntity)) - { - childGroupEntity.CalculationGroupEntity2.CalculationGroupEntity1.Remove(childGroupEntity); - entity.CalculationGroupEntity1.Add(childGroupEntity); - } + childCalculationEntity.CalculationGroupEntity.PipingCalculationEntities.Remove(childCalculationEntity); + entity.PipingCalculationEntities.Add(childCalculationEntity); } } + } + } - var childCalculationScenario = calculationBase as PipingCalculationScenario; - if (childCalculationScenario != null) + private static void UpdateIfGrassCoverErosionInwardsCalculation(CalculationGroupEntity entity, + PersistenceRegistry registry, + IRingtoetsEntities context, + ICalculationBase calculationBase, + int order) + { + var childCalculation = calculationBase as GrassCoverErosionInwardsCalculation; + if (childCalculation != null) + { + if (childCalculation.IsNew()) { - if (childCalculationScenario.IsNew()) + entity.GrassCoverErosionInwardsCalculationEntities.Add(childCalculation.Create(registry, order)); + } + else + { + childCalculation.Update(registry, context, order); + GrassCoverErosionInwardsCalculationEntity childCalculationEntity = context.GrassCoverErosionInwardsCalculationEntities.First(cge => cge.GrassCoverErosionInwardsCalculationEntityId == childCalculation.StorageId); + if (!entity.GrassCoverErosionInwardsCalculationEntities.Contains(childCalculationEntity)) { - entity.PipingCalculationEntities.Add(childCalculationScenario.Create(registry, i)); + childCalculationEntity.CalculationGroupEntity.GrassCoverErosionInwardsCalculationEntities.Remove(childCalculationEntity); + entity.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity); } - else - { - childCalculationScenario.Update(registry, context); - PipingCalculationEntity childPipingCalculationEntity = context.PipingCalculationEntities.First(cge => cge.PipingCalculationEntityId == childCalculationScenario.StorageId); - childPipingCalculationEntity.Order = i; - if (!entity.PipingCalculationEntities.Contains(childPipingCalculationEntity)) - { - childPipingCalculationEntity.CalculationGroupEntity.PipingCalculationEntities.Remove(childPipingCalculationEntity); - entity.PipingCalculationEntities.Add(childPipingCalculationEntity); - } - } } } } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/GrassCoverErosionInwards/GrassCoverErosionInwardsFailureMechanismUpdateExtensions.cs =================================================================== diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/GrassCoverErosionInwards/GrassCoverErosionInwardsFailureMechanismUpdateExtensions.cs (.../GrassCoverErosionInwardsFailureMechanismUpdateExtensions.cs) (revision a5714fc0488030773fff50dfc82041c6cb9edc2f) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/GrassCoverErosionInwards/GrassCoverErosionInwardsFailureMechanismUpdateExtensions.cs (.../GrassCoverErosionInwardsFailureMechanismUpdateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -70,7 +70,7 @@ UpdateDikeProfiles(mechanism, registry, entity, context); mechanism.UpdateFailureMechanismSections(registry, entity, context); UpdateSectionResults(mechanism, registry, context); - mechanism.CalculationsGroup.Update(registry, context); + mechanism.CalculationsGroup.Update(registry, context, 0); registry.Register(entity, mechanism); } Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingCalculationScenarioUpdateExtensions.cs =================================================================== diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingCalculationScenarioUpdateExtensions.cs (.../PipingCalculationScenarioUpdateExtensions.cs) (revision a5714fc0488030773fff50dfc82041c6cb9edc2f) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingCalculationScenarioUpdateExtensions.cs (.../PipingCalculationScenarioUpdateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -43,14 +43,16 @@ /// The piping calculation to update the database entity for. /// The object keeping track of update operations. /// The context to obtain the existing entity from. + /// The index at which resides + /// in its parent container. /// Thrown when either: /// /// is null /// is null /// /// When /// does not have a corresponding entity in the database. - internal static void Update(this PipingCalculationScenario calculation, PersistenceRegistry registry, IRingtoetsEntities context) + internal static void Update(this PipingCalculationScenario calculation, PersistenceRegistry registry, IRingtoetsEntities context, int order) { if (registry == null) { @@ -68,6 +70,7 @@ entity.ScenarioContribution = Convert.ToDecimal(calculation.Contribution); entity.Name = calculation.Name; entity.Comments = calculation.Comments; + entity.Order = order; SetInputParameters(entity, calculation.InputParameters, registry); UpdatePipingCalculationOutputs(entity, calculation, registry); Index: Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingFailureMechanismUpdateExtensions.cs =================================================================== diff -u -ra5714fc0488030773fff50dfc82041c6cb9edc2f -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingFailureMechanismUpdateExtensions.cs (.../PipingFailureMechanismUpdateExtensions.cs) (revision a5714fc0488030773fff50dfc82041c6cb9edc2f) +++ Application/Ringtoets/src/Application.Ringtoets.Storage/Update/Piping/PipingFailureMechanismUpdateExtensions.cs (.../PipingFailureMechanismUpdateExtensions.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -73,7 +73,7 @@ UpdateSurfaceLines(mechanism, registry, context, entity); mechanism.UpdateFailureMechanismSections(registry, entity, context); UpdateSectionResults(mechanism, registry, context); - mechanism.CalculationsGroup.Update(registry, context); + mechanism.CalculationsGroup.Update(registry, context, 0); registry.Register(entity, mechanism); } Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs =================================================================== diff -u -rbba617101367a21a38bf41ad520662058b9012af -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision bba617101367a21a38bf41ad520662058b9012af) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Create/CalculationGroupCreateExtensionsTest.cs (.../CalculationGroupCreateExtensionsTest.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -28,6 +28,7 @@ using NUnit.Framework; using Ringtoets.Common.Data.Calculation; +using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.Piping.Data; namespace Application.Ringtoets.Storage.Test.Create @@ -215,5 +216,94 @@ Assert.AreEqual("D", childEntity4.Name); Assert.AreEqual(3, childEntity4.Order); } + + [Test] + public void Create_GroupWithChildGrassCoverErosionInwardsCalculations_CreateEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new GrassCoverErosionInwardsCalculation + { + Name = "A" + }, + new GrassCoverErosionInwardsCalculation + { + Name = "B" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + GrassCoverErosionInwardsCalculationEntity[] childCalculationEntities = entity.GrassCoverErosionInwardsCalculationEntities.ToArray(); + Assert.AreEqual(2, childCalculationEntities.Length); + + GrassCoverErosionInwardsCalculationEntity childEntity1 = childCalculationEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(0, childEntity1.Order); + GrassCoverErosionInwardsCalculationEntity childEntity2 = childCalculationEntities[1]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + } + + [Test] + public void Create_GroupWithChildGrassCoverErosionInwardCalculationsAndChildCalculationGroups_CreateEntities() + { + // Setup + var group = new CalculationGroup("root", true) + { + Children = + { + new CalculationGroup("A", true), + new GrassCoverErosionInwardsCalculation + { + Name = "B" + }, + new CalculationGroup("C", false), + new GrassCoverErosionInwardsCalculation + { + Name = "D" + } + } + }; + + var registry = new PersistenceRegistry(); + + // Call + CalculationGroupEntity entity = group.Create(registry, 0); + + // Assert + CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity1.ToArray(); + GrassCoverErosionInwardsCalculationEntity[] childCalculationEntities = entity.GrassCoverErosionInwardsCalculationEntities.ToArray(); + Assert.AreEqual(2, childGroupEntities.Length); + Assert.AreEqual(2, childCalculationEntities.Length); + + CalculationGroupEntity childEntity1 = childGroupEntities[0]; + Assert.AreEqual("A", childEntity1.Name); + Assert.AreEqual(1, childEntity1.IsEditable); + Assert.AreEqual(0, childEntity1.Order); + CollectionAssert.IsEmpty(childEntity1.CalculationGroupEntity1); + + GrassCoverErosionInwardsCalculationEntity childEntity2 = childCalculationEntities[0]; + Assert.AreEqual("B", childEntity2.Name); + Assert.AreEqual(1, childEntity2.Order); + + CalculationGroupEntity childEntity3 = childGroupEntities[1]; + Assert.AreEqual("C", childEntity3.Name); + Assert.AreEqual(0, childEntity3.IsEditable); + Assert.AreEqual(2, childEntity3.Order); + CollectionAssert.IsEmpty(childEntity3.CalculationGroupEntity1); + + GrassCoverErosionInwardsCalculationEntity childEntity4 = childCalculationEntities[1]; + Assert.AreEqual("D", childEntity4.Name); + Assert.AreEqual(3, childEntity4.Order); + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs =================================================================== diff -u -rc28cee59f7b527892aa7e5d8acb92fc9732196e9 -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision c28cee59f7b527892aa7e5d8acb92fc9732196e9) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/IntegrationTests/StorageSqLiteIntegrationTest.cs (.../StorageSqLiteIntegrationTest.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -811,7 +811,11 @@ { AssertPipingCalculationScenario(expectedPipingCalculation, (PipingCalculationScenario) actualChild); } - // TODO GEBK Berekening + var expectedGrassCoverErosionInwardsCalculation = expectedChild as GrassCoverErosionInwardsCalculation; + if (expectedGrassCoverErosionInwardsCalculation != null) + { + AssertGrassCoverErosionInwardsCalculation(expectedGrassCoverErosionInwardsCalculation, (GrassCoverErosionInwardsCalculation)actualChild); + } } } @@ -890,6 +894,12 @@ } } + private void AssertGrassCoverErosionInwardsCalculation(GrassCoverErosionInwardsCalculation expectedCalculation, GrassCoverErosionInwardsCalculation actualCalculation) + { + Assert.AreEqual(expectedCalculation.Name, actualCalculation.Name); + Assert.AreEqual(expectedCalculation.Comments, actualCalculation.Comments); + } + private void AssertGrassCoverErosionInwardsFailureMechanism(GrassCoverErosionInwardsFailureMechanism expectedFailureMechanism, GrassCoverErosionInwardsFailureMechanism actualFailureMechanism) { Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs =================================================================== diff -u -r93f4c75ba2309bb82de7e2362bafca5aa516d545 -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision 93f4c75ba2309bb82de7e2362bafca5aa516d545) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Read/CalculationGroupEntityReadExtentionsTest.cs (.../CalculationGroupEntityReadExtentionsTest.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -28,6 +28,7 @@ using NUnit.Framework; using Ringtoets.Common.Data.Calculation; +using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.Piping.Data; namespace Application.Ringtoets.Storage.Test.Read @@ -416,7 +417,113 @@ CollectionAssert.IsEmpty(rootChildGroup1Child2.Children); } - // TODO Calculations - // TODO Groups and Calculations + [Test] + public void ReadAsGrassCoverErosionInwardsCalculationGroup_EntityWithChildGrassCoverErosionInwardsCalculations_CreateCalculationGroupWithChildCalculations() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + CalculationGroupEntityId = 1, + Name = "A", + GrassCoverErosionInwardsCalculationEntities = + { + new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = 3, + Order = 0, + Name = "1" + }, + new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = 6, + Order = 1, + Name = "2" + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + var rootGroup = rootGroupEntity.ReadAsGrassCoverErosionInwardsCalculationGroup(collector); + + // Assert + ICalculationBase[] rootChildren = rootGroup.Children.ToArray(); + Assert.AreEqual(2, rootChildren.Length); + + var rootChildCalculation1 = (GrassCoverErosionInwardsCalculation)rootChildren[0]; + Assert.AreEqual("1", rootChildCalculation1.Name); + Assert.AreEqual(3, rootChildCalculation1.StorageId); + + var rootChildCalculation2 = (GrassCoverErosionInwardsCalculation)rootChildren[1]; + Assert.AreEqual("2", rootChildCalculation2.Name); + Assert.AreEqual(6, rootChildCalculation2.StorageId); + } + + [Test] + public void ReadAsGrassCoverErosionInwardsCalculationGroup_EntityWithChildGrassCoverErosionInwardsCalculationsAndGroups_CreateCalculationGroupWithChildCalculationsAndGroups() + { + // Setup + var rootGroupEntity = new CalculationGroupEntity + { + CalculationGroupEntityId = 1, + Name = "A", + GrassCoverErosionInwardsCalculationEntities = + { + new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = 3, + Order = 0, + Name = "calculation1" + }, + new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = 6, + Order = 2, + Name = "calculation2" + } + }, + CalculationGroupEntity1 = + { + new CalculationGroupEntity + { + CalculationGroupEntityId = 2, + Order = 1, + Name = "group1" + }, + new CalculationGroupEntity + { + CalculationGroupEntityId = 4, + Order = 3, + Name = "group2" + } + } + }; + + var collector = new ReadConversionCollector(); + + // Call + var rootGroup = rootGroupEntity.ReadAsGrassCoverErosionInwardsCalculationGroup(collector); + + // Assert + ICalculationBase[] rootChildren = rootGroup.Children.ToArray(); + Assert.AreEqual(4, rootChildren.Length); + + var rootChildCalculation1 = (GrassCoverErosionInwardsCalculation)rootChildren[0]; + Assert.AreEqual("calculation1", rootChildCalculation1.Name); + Assert.AreEqual(3, rootChildCalculation1.StorageId); + + var rootChildGroup1 = (CalculationGroup)rootChildren[1]; + Assert.AreEqual("group1", rootChildGroup1.Name); + Assert.AreEqual(2, rootChildGroup1.StorageId); + + var rootChildCalculation2 = (GrassCoverErosionInwardsCalculation)rootChildren[2]; + Assert.AreEqual("calculation2", rootChildCalculation2.Name); + Assert.AreEqual(6, rootChildCalculation2.StorageId); + + var rootChildGroup2 = (CalculationGroup)rootChildren[3]; + Assert.AreEqual("group2", rootChildGroup2.Name); + Assert.AreEqual(4, rootChildGroup2.StorageId); + } } } \ No newline at end of file Index: Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/CalculationGroupUpdateExtensionsTest.cs =================================================================== diff -u -r01ff2c58c13df8f42661ae3e446dc2caaa94247e -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/CalculationGroupUpdateExtensionsTest.cs (.../CalculationGroupUpdateExtensionsTest.cs) (revision 01ff2c58c13df8f42661ae3e446dc2caaa94247e) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.Test/Update/CalculationGroupUpdateExtensionsTest.cs (.../CalculationGroupUpdateExtensionsTest.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -34,7 +34,9 @@ using Rhino.Mocks; using Ringtoets.Common.Data.Calculation; +using Ringtoets.GrassCoverErosionInwards.Data; using Ringtoets.Piping.Data; +using Application.Ringtoets.Storage.Create.GrassCoverErosionInwards; namespace Application.Ringtoets.Storage.Test.Update { @@ -55,7 +57,7 @@ }; // Call - TestDelegate call = () => calculationGroup.Update(null, rintoetsEntities); + TestDelegate call = () => calculationGroup.Update(null, rintoetsEntities, 0); // Assert string paramName = Assert.Throws(call).ParamName; @@ -75,7 +77,7 @@ var registry = new PersistenceRegistry(); // Call - TestDelegate call = () => calculationGroup.Update(registry, null); + TestDelegate call = () => calculationGroup.Update(registry, null, 0); // Assert string paramName = Assert.Throws(call).ParamName; @@ -98,7 +100,7 @@ var registry = new PersistenceRegistry(); // Call - TestDelegate call = () => calculationGroup.Update(registry, ringtoetsEntities); + TestDelegate call = () => calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert string message = Assert.Throws(call).Message; @@ -120,17 +122,21 @@ { CalculationGroupEntityId = calculationGroup.StorageId, IsEditable = Convert.ToByte(calculationGroup.IsNameEditable), - Name = "" + Name = "", + Order = 0 }; ringtoetsEntities.CalculationGroupEntities.Add(groupEntity); var registry = new PersistenceRegistry(); + const int newOrder = 2; + // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, newOrder); // Assert Assert.AreEqual(calculationGroup.Name, groupEntity.Name); + Assert.AreEqual(newOrder, groupEntity.Order); CollectionAssert.IsEmpty(groupEntity.CalculationGroupEntity1, "No changes to the children expected."); @@ -159,7 +165,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert Assert.AreEqual(calculationGroup.Name, groupEntity.Name); @@ -210,7 +216,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert Assert.AreEqual(0, childGroupEntity1.Order); @@ -254,7 +260,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert CalculationGroupEntity[] updatedChildGroupEntities = groupEntity.CalculationGroupEntity1 @@ -295,7 +301,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert CalculationGroupEntity[] updatedChildGroupEntities = rootGroupEntity.CalculationGroupEntity1 @@ -345,7 +351,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert Assert.AreEqual(0, draggedGroupEntity.Order); @@ -396,7 +402,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert Assert.AreEqual(0, childCalculationEntity1.Order); @@ -440,7 +446,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert PipingCalculationEntity[] updatedChildPipingCalculationEntities = groupEntity.PipingCalculationEntities @@ -480,7 +486,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert PipingCalculationEntity[] updatedChildPipingCalculationEntities = rootGroupEntity.PipingCalculationEntities @@ -530,7 +536,7 @@ var registry = new PersistenceRegistry(); // Call - calculationGroup.Update(registry, ringtoetsEntities); + calculationGroup.Update(registry, ringtoetsEntities, 0); // Assert Assert.AreEqual(0, draggedPipingCalculationEntity.Order); @@ -541,6 +547,191 @@ mocks.VerifyAll(); } + [Test] + public void Update_ChildGrassCoverErosionInwardsCalculationsReordered_EntitiesUpdated() + { + // Setup + var mocks = new MockRepository(); + IRingtoetsEntities ringtoetsEntities = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + CalculationGroup calculationGroup = CreateCalculationGroupWith2ChildGrassCoverErosionInwardsCalculations(); + + var childCalculationEntity1 = new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = ((GrassCoverErosionInwardsCalculation)calculationGroup.Children[0]).StorageId, + Name = "A", + Order = 1 + }; + var childCalculationEntity2 = new GrassCoverErosionInwardsCalculationEntity + { + GrassCoverErosionInwardsCalculationEntityId = ((GrassCoverErosionInwardsCalculation)calculationGroup.Children[1]).StorageId, + Name = "B", + Order = 0 + }; + var groupEntity = new CalculationGroupEntity + { + CalculationGroupEntityId = calculationGroup.StorageId, + IsEditable = Convert.ToByte(calculationGroup.IsNameEditable), + Name = "", + GrassCoverErosionInwardsCalculationEntities = + { + childCalculationEntity1, + childCalculationEntity2 + } + }; + ringtoetsEntities.CalculationGroupEntities.Add(groupEntity); + ringtoetsEntities.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity1); + ringtoetsEntities.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity2); + + var registry = new PersistenceRegistry(); + + // Call + calculationGroup.Update(registry, ringtoetsEntities, 0); + + // Assert + Assert.AreEqual(0, childCalculationEntity1.Order); + Assert.AreEqual(calculationGroup.Children[0].Name, childCalculationEntity1.Name); + Assert.AreEqual(1, childCalculationEntity2.Order); + Assert.AreEqual(calculationGroup.Children[1].Name, childCalculationEntity2.Name); + mocks.VerifyAll(); + } + + [Test] + public void Update_ChildGrassCoverErosionInwardsCalculationsInserted_EntitiesUpdatedAndNewEntityCreated() + { + // Setup + var mocks = new MockRepository(); + IRingtoetsEntities ringtoetsEntities = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + CalculationGroup calculationGroup = CreateCalculationGroupWith2ChildGrassCoverErosionInwardsCalculations(); + + GrassCoverErosionInwardsCalculationEntity childCalculationEntity1 = CreateExpectedGrassCoverErosionInwardsCalculationEntity((GrassCoverErosionInwardsCalculation)calculationGroup.Children[0], 0); + GrassCoverErosionInwardsCalculationEntity childCalculationEntity2 = CreateExpectedGrassCoverErosionInwardsCalculationEntity((GrassCoverErosionInwardsCalculation)calculationGroup.Children[1], 1); + var groupEntity = new CalculationGroupEntity + { + CalculationGroupEntityId = calculationGroup.StorageId, + IsEditable = Convert.ToByte(calculationGroup.IsNameEditable), + Name = "", + GrassCoverErosionInwardsCalculationEntities = + { + childCalculationEntity1, + childCalculationEntity2 + } + }; + ringtoetsEntities.CalculationGroupEntities.Add(groupEntity); + ringtoetsEntities.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity1); + ringtoetsEntities.GrassCoverErosionInwardsCalculationEntities.Add(childCalculationEntity2); + + var insertedCalculation = new GrassCoverErosionInwardsCalculation(); + const int insertedIndex = 1; + calculationGroup.Children.Insert(insertedIndex, insertedCalculation); + + var registry = new PersistenceRegistry(); + + // Call + calculationGroup.Update(registry, ringtoetsEntities, 0); + + // Assert + GrassCoverErosionInwardsCalculationEntity[] updatedChildCalculationEntities = groupEntity.GrassCoverErosionInwardsCalculationEntities + .OrderBy(cge => cge.Order) + .ToArray(); + Assert.AreEqual(3, updatedChildCalculationEntities.Length); + Assert.AreSame(childCalculationEntity1, updatedChildCalculationEntities[0]); + Assert.AreEqual(0, childCalculationEntity1.Order); + Assert.AreEqual(calculationGroup.Children[0].Name, childCalculationEntity1.Name); + + GrassCoverErosionInwardsCalculationEntity newCalculationEntity = updatedChildCalculationEntities[insertedIndex]; + Assert.AreEqual(insertedIndex, newCalculationEntity.Order); + Assert.AreEqual(insertedCalculation.Name, newCalculationEntity.Name); + + Assert.AreSame(childCalculationEntity2, updatedChildCalculationEntities[2]); + Assert.AreEqual(2, childCalculationEntity2.Order); + Assert.AreEqual(calculationGroup.Children[2].Name, childCalculationEntity2.Name); + mocks.VerifyAll(); + } + + [Test] + public void Update_ChildGrassCoverErosionInwardsCalculationAdded_RootEntityUpdatedAndNewEntityCreated() + { + // Setup + var mocks = new MockRepository(); + IRingtoetsEntities ringtoetsEntities = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + CalculationGroup calculationGroup = CreateCalculationGroupWithoutChildren(true); + + CalculationGroupEntity rootGroupEntity = CreateExpectedEmptyGroupEntity(calculationGroup, 0); + ringtoetsEntities.CalculationGroupEntities.Add(rootGroupEntity); + + var newCalculation = new GrassCoverErosionInwardsCalculation(); + calculationGroup.Children.Add(newCalculation); + + var registry = new PersistenceRegistry(); + + // Call + calculationGroup.Update(registry, ringtoetsEntities, 0); + + // Assert + GrassCoverErosionInwardsCalculationEntity[] updatedChildCalculationEntities = rootGroupEntity.GrassCoverErosionInwardsCalculationEntities + .OrderBy(cge => cge.Order) + .ToArray(); + Assert.AreEqual(1, updatedChildCalculationEntities.Length); + GrassCoverErosionInwardsCalculationEntity newGroupEntity = updatedChildCalculationEntities[0]; + Assert.AreEqual(0, newGroupEntity.Order); + Assert.AreEqual(newCalculation.Name, newGroupEntity.Name); + mocks.VerifyAll(); + } + + [Test] + public void Update_ExistingChildGrassCoverErosionInwardsCalculationDragged_EntitiesUpdated() + { + // Setup + var mocks = new MockRepository(); + IRingtoetsEntities ringtoetsEntities = RingtoetsEntitiesHelper.CreateStub(mocks); + mocks.ReplayAll(); + + var draggedCalculation = new GrassCoverErosionInwardsCalculation + { + Name = "", + StorageId = 87768 + }; + CalculationGroup calculationGroup = CreateCalculationGroupWith2ChildGroups(); + ((CalculationGroup)calculationGroup.Children[0]).Children.Add(draggedCalculation); + + CalculationGroupEntity childGroup1Entity = CreateExpectedEmptyGroupEntity((CalculationGroup)calculationGroup.Children[0], 0); + CalculationGroupEntity childGroup2Entity = CreateExpectedEmptyGroupEntity((CalculationGroup)calculationGroup.Children[1], 1); + CalculationGroupEntity fillerGroupEntity = CreateExpectedEmptyGroupEntity(new CalculationGroup(), 0); + childGroup2Entity.CalculationGroupEntity1.Add(fillerGroupEntity); + GrassCoverErosionInwardsCalculationEntity draggedCalculationEntity = CreateExpectedGrassCoverErosionInwardsCalculationEntity(draggedCalculation, 1); + childGroup2Entity.GrassCoverErosionInwardsCalculationEntities.Add(draggedCalculationEntity); + draggedCalculationEntity.CalculationGroupEntity = childGroup2Entity; + + CalculationGroupEntity rootGroupEntity = CreateExpectedEmptyGroupEntity(calculationGroup, 0); + rootGroupEntity.CalculationGroupEntity1.Add(childGroup1Entity); + rootGroupEntity.CalculationGroupEntity1.Add(childGroup2Entity); + + ringtoetsEntities.CalculationGroupEntities.Add(rootGroupEntity); + ringtoetsEntities.CalculationGroupEntities.Add(childGroup1Entity); + ringtoetsEntities.CalculationGroupEntities.Add(childGroup2Entity); + ringtoetsEntities.CalculationGroupEntities.Add(fillerGroupEntity); + ringtoetsEntities.GrassCoverErosionInwardsCalculationEntities.Add(draggedCalculationEntity); + + var registry = new PersistenceRegistry(); + + // Call + calculationGroup.Update(registry, ringtoetsEntities, 0); + + // Assert + Assert.AreEqual(0, draggedCalculationEntity.Order); + CollectionAssert.Contains(childGroup1Entity.GrassCoverErosionInwardsCalculationEntities, draggedCalculationEntity); + CollectionAssert.DoesNotContain(childGroup2Entity.GrassCoverErosionInwardsCalculationEntities, draggedCalculationEntity); + + Assert.AreEqual(0, fillerGroupEntity.Order); + mocks.VerifyAll(); + } + private static CalculationGroup CreateCalculationGroupWithoutChildren(bool isNameEditable) { return new CalculationGroup("", isNameEditable) @@ -588,6 +779,25 @@ }; } + private CalculationGroup CreateCalculationGroupWith2ChildGrassCoverErosionInwardsCalculations() + { + return new CalculationGroup(" calculation.Update(null, context); + TestDelegate call = () => calculation.Update(null, context, 0); // Assert string paramName = Assert.Throws(call).ParamName; @@ -71,7 +71,7 @@ var registry = new PersistenceRegistry(); // Call - TestDelegate call = () => calculation.Update(registry, null); + TestDelegate call = () => calculation.Update(registry, null, 0); // Assert string paramName = Assert.Throws(call).ParamName; @@ -91,7 +91,7 @@ var calculation = new PipingCalculationScenario(new GeneralPipingInput()); // Call - TestDelegate call = () => calculation.Update(registry, context); + TestDelegate call = () => calculation.Update(registry, context, 0); // Assert Assert.Throws(call); @@ -154,14 +154,17 @@ } }; + const int newOrder = 5; + // Call - calculation.Update(registry, context); + calculation.Update(registry, context, newOrder); // Assert Assert.AreEqual(Convert.ToByte(calculation.IsRelevant), entity.RelevantForScenario); Assert.AreEqual(Convert.ToDecimal(calculation.Contribution), entity.ScenarioContribution); Assert.AreEqual(calculation.Name, entity.Name); Assert.AreEqual(calculation.Comments, entity.Comments); + Assert.AreEqual(newOrder, entity.Order); PipingInput inputParameters = calculation.InputParameters; Assert.AreEqual(inputParameters.EntryPointL.Value.ToNullableDecimal(), entity.EntryPointL); @@ -255,7 +258,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNotNull(entity.SurfaceLineEntity); @@ -317,7 +320,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNull(entity.SurfaceLineEntity); @@ -392,7 +395,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.AreSame(replacementHydraulicLocationEntity, entity.HydraulicLocationEntity); @@ -454,7 +457,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNull(entity.HydraulicLocationEntity); @@ -527,7 +530,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.AreSame(replacementStochasticSoilProfileEntity, entity.StochasticSoilProfileEntity); @@ -586,7 +589,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNull(entity.StochasticSoilProfileEntity); @@ -640,7 +643,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert PipingCalculationOutputEntity pipingCalculationOutputEntity = entity.PipingCalculationOutputEntity; @@ -704,7 +707,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert CollectionAssert.Contains(context.PipingCalculationOutputEntities, calculationOutputEntity); @@ -763,7 +766,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNull(entity.PipingCalculationOutputEntity); @@ -821,7 +824,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert PipingSemiProbabilisticOutputEntity semiProbabilisticOutputEntity = entity.PipingSemiProbabilisticOutputEntity; @@ -889,7 +892,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert CollectionAssert.Contains(context.PipingSemiProbabilisticOutputEntities, semiProbabilisticOutputEntity); @@ -948,7 +951,7 @@ }; // Call - calculation.Update(registry, context); + calculation.Update(registry, context, 0); // Assert Assert.IsNull(entity.PipingSemiProbabilisticOutputEntity); Index: Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs =================================================================== diff -u -r93f4c75ba2309bb82de7e2362bafca5aa516d545 -r06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98 --- Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs (.../RingtoetsProjectHelper.cs) (revision 93f4c75ba2309bb82de7e2362bafca5aa516d545) +++ Application/Ringtoets/test/Application.Ringtoets.Storage.TestUtil/RingtoetsProjectHelper.cs (.../RingtoetsProjectHelper.cs) (revision 06e4debe3f4a9bdfb38c40b8c00ed013e8f7bb98) @@ -296,15 +296,31 @@ })); failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup { - Name = "GEKB A" + Name = "GEKB A", + Children = + { + new GrassCoverErosionInwardsCalculation + { + Name = "Calculation 1", + Comments = "Comments for Calculation 1" + } + } }); failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup { Name = "GEKB B" }); failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup { - Name = "GEKB C" + Name = "GEKB C", + Children = + { + new GrassCoverErosionInwardsCalculation + { + Name = "Calculation 2", + Comments = "Comments about Calculation 2" + } + } }); }