Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs
===================================================================
diff -u
--- Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs	(revision 0)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Test/FileImporters/ForeshoreProfileUpdateDataStrategyIntegrationTest.cs	(revision 73f750ed255e5084397520aa04a5c855257e7b73)
@@ -0,0 +1,628 @@
+// 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 <http://www.gnu.org/licenses/>.
+//
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Core.Common.Base;
+using Core.Common.Base.Data;
+using Core.Common.Base.Geometry;
+using Core.Common.TestUtil;
+using NUnit.Framework;
+using Ringtoets.ClosingStructures.Data;
+using Ringtoets.ClosingStructures.Data.TestUtil;
+using Ringtoets.Common.Data.Calculation;
+using Ringtoets.Common.Data.DikeProfiles;
+using Ringtoets.Common.Data.TestUtil;
+using Ringtoets.GrassCoverErosionOutwards.Data;
+using Ringtoets.HeightStructures.Data;
+using Ringtoets.HeightStructures.Data.TestUtil;
+using Ringtoets.Integration.Plugin.FileImporters;
+using Ringtoets.Integration.TestUtils;
+using Ringtoets.Revetment.TestUtil;
+using Ringtoets.StabilityPointStructures.Data;
+using Ringtoets.StabilityPointStructures.Data.TestUtil;
+using Ringtoets.StabilityStoneCover.Data;
+using Ringtoets.WaveImpactAsphaltCover.Data;
+
+namespace Ringtoets.Integration.Test.FileImporters
+{
+    [TestFixture]
+    public class ForeshoreProfileUpdateDataStrategyIntegrationTest
+    {
+        private const string sourceFilePath = "path/to/foreshoreProfiles";
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredWaveImpactAsphaltCoverFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            WaveImpactAsphaltCoverFailureMechanism failureMechanism =
+                TestDataGenerator.GetWaveImpactAsphaltCoverFailureMechanismWithAllCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new WaveImpactAsphaltCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new WaveImpactAsphaltCoverWaveConditionsOutput(new[]
+                {
+                    new TestWaveConditionsOutput()
+                })
+            };
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredGrassCoverOutwardsFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            GrassCoverErosionOutwardsFailureMechanism failureMechanism =
+                TestDataGenerator.GetGrassCoverErosionOutwardsFailureMechanismWithAllCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new GrassCoverErosionOutwardsWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new GrassCoverErosionOutwardsWaveConditionsOutput(new[]
+                {
+                    new TestWaveConditionsOutput()
+                })
+            };
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredStabilityStoneCoverFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            StabilityStoneCoverFailureMechanism failureMechanism =
+                TestDataGenerator.GetStabilityStoneCoverFailureMechanismWithAllCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new StabilityStoneCoverWaveConditionsCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new StabilityStoneCoverWaveConditionsOutput(new[]
+                {
+                    new TestWaveConditionsOutput()
+                }, new[]
+                {
+                    new TestWaveConditionsOutput()
+                })
+            };
+            failureMechanism.WaveConditionsCalculationGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredHeightStructuresFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            HeightStructuresFailureMechanism failureMechanism =
+                TestDataGenerator.GetHeightStructuresFailureMechanismWithAlLCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new TestHeightStructuresCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new TestStructuresOutput()
+            };
+            failureMechanism.CalculationsGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredStabilityPointStructuresFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            StabilityPointStructuresFailureMechanism failureMechanism =
+                TestDataGenerator.GetStabilityPointStructuresFailureMechanismWithAllCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new TestStabilityPointStructuresCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new TestStructuresOutput()
+            };
+            failureMechanism.CalculationsGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        [Test]
+        public void UpdateForeshoreProfilesWithImportedData_FullyConfiguredClosingStructuresFailureMechanism_UpdatesAffectedCalculation()
+        {
+            // Setup
+            ClosingStructuresFailureMechanism failureMechanism =
+                TestDataGenerator.GetClosingStructuresFailureMechanismWithAllCalculationConfigurations();
+
+            ForeshoreProfile profileToBeUpdated = failureMechanism.ForeshoreProfiles[0];
+            ForeshoreProfile profileToUpdateFrom = DeepCloneAndModify(profileToBeUpdated);
+            ForeshoreProfile profileToBeRemoved = failureMechanism.ForeshoreProfiles[1];
+
+            const string unaffectedProfileName = "Custom Profile";
+            const string unaffectedProfileId = "Custom ID";
+            var unaffectedProfile = new TestForeshoreProfile(unaffectedProfileName, unaffectedProfileId);
+            failureMechanism.ForeshoreProfiles.AddRange(new[]
+            {
+                unaffectedProfile
+            }, sourceFilePath);
+            var unaffectedCalculation = new TestClosingStructuresCalculation
+            {
+                InputParameters =
+                {
+                    ForeshoreProfile = unaffectedProfile
+                },
+                Output = new TestStructuresOutput()
+            };
+            failureMechanism.CalculationsGroup.Children.Add(unaffectedCalculation);
+
+            var strategy = new ForeshoreProfileUpdateDataStrategy(failureMechanism);
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeUpdated))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithUpdatedForeshoreProfileWithOutputs =
+                calculationsWithUpdatedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfile =
+                failureMechanism.Calculations
+                                .Cast<ICalculation<ICalculationInput>>()
+                                .Where(calc => ReferenceEquals(((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile,
+                                                               profileToBeRemoved))
+                                .ToArray();
+
+            ICalculation<ICalculationInput>[] calculationsWithRemovedForeshoreProfileWithOutputs =
+                calculationsWithRemovedForeshoreProfile.Where(calc => calc.HasOutput)
+                                                       .ToArray();
+
+            // Call
+            IEnumerable<IObservable> affectedObjects =
+                strategy.UpdateForeshoreProfilesWithImportedData(failureMechanism.ForeshoreProfiles,
+                                                                 new[]
+                                                                 {
+                                                                     profileToUpdateFrom,
+                                                                     new TestForeshoreProfile(unaffectedProfileName,
+                                                                                              unaffectedProfileId)
+                                                                 },
+                                                                 sourceFilePath);
+
+            // Assert
+            Assert.IsTrue(unaffectedCalculation.HasOutput);
+            Assert.AreSame(unaffectedProfile, unaffectedCalculation.InputParameters.ForeshoreProfile);
+
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithUpdatedForeshoreProfile.All(calc => ReferenceEquals(GetForeshoreProfile(calc),
+                                                                                              profileToBeUpdated)));
+
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => !calc.HasOutput));
+            Assert.IsTrue(calculationsWithRemovedForeshoreProfile.All(calc => GetForeshoreProfile(calc) == null));
+
+            var expectedAffectedObjects = new List<IObservable>
+            {
+                failureMechanism.ForeshoreProfiles,
+                profileToBeUpdated
+            };
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfileWithOutputs);
+            expectedAffectedObjects.AddRange(calculationsWithUpdatedForeshoreProfile.Select(calc => calc.InputParameters));
+            expectedAffectedObjects.AddRange(calculationsWithRemovedForeshoreProfile.Select(calc => calc.InputParameters));
+
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+        }
+
+        private static ForeshoreProfile GetForeshoreProfile(ICalculation<ICalculationInput> calc)
+        {
+            return ((IHasForeshoreProfile) calc.InputParameters).ForeshoreProfile;
+        }
+
+        /// <summary>
+        /// Makes a deep clone of the foreshore profile and modifies all the properties,
+        /// except the <see cref="ForeshoreProfile.Id"/>.
+        /// </summary>
+        /// <param name="foreshoreProfile">The foreshore profile to deep clone.</param>
+        /// <returns>A deep clone of the <paramref name="foreshoreProfile"/>.</returns>
+        private static ForeshoreProfile DeepCloneAndModify(ForeshoreProfile foreshoreProfile)
+        {
+            var random = new Random(21);
+
+            Point2D originalWorldCoordinate = foreshoreProfile.WorldReferencePoint;
+            var modifiedWorldCoordinate = new Point2D(originalWorldCoordinate.X + random.NextDouble(),
+                                                      originalWorldCoordinate.Y + random.NextDouble());
+
+            List<Point2D> modifiedForeshoreGeometry = foreshoreProfile.Geometry.ToList();
+            modifiedForeshoreGeometry.Add(new Point2D(1, 2));
+
+            RoundedDouble originalBreakWaterHeight = foreshoreProfile.BreakWater?.Height ?? (RoundedDouble) 0.0;
+            var modifiedBreakWater = new BreakWater(random.NextEnumValue<BreakWaterType>(),
+                                                    originalBreakWaterHeight + random.NextDouble());
+
+            string modifiedName = $"new_name_{foreshoreProfile.Name}";
+            double modifiedOrientation = foreshoreProfile.Orientation + random.NextDouble();
+            double modifiedX0 = foreshoreProfile.X0 + random.NextDouble();
+
+            return new ForeshoreProfile(modifiedWorldCoordinate, modifiedForeshoreGeometry,
+                                        modifiedBreakWater,
+                                        new ForeshoreProfile.ConstructionProperties
+                                        {
+                                            Name = modifiedName,
+                                            Id = foreshoreProfile.Id,
+                                            Orientation = modifiedOrientation,
+                                            X0 = modifiedX0
+                                        });
+        }
+    }
+}
\ No newline at end of file
Index: Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj
===================================================================
diff -u -r9b0af3f940ae57b373ab4edfd7da944090255fde -r73f750ed255e5084397520aa04a5c855257e7b73
--- Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj	(.../Ringtoets.Integration.Test.csproj)	(revision 9b0af3f940ae57b373ab4edfd7da944090255fde)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Test/Ringtoets.Integration.Test.csproj	(.../Ringtoets.Integration.Test.csproj)	(revision 73f750ed255e5084397520aa04a5c855257e7b73)
@@ -60,6 +60,7 @@
       <Link>Properties\GlobalAssembly.cs</Link>
     </Compile>
     <Compile Include="FileImporters\ForeshoreProfileReplaceDataStrategyIntegrationTest.cs" />
+    <Compile Include="FileImporters\ForeshoreProfileUpdateDataStrategyIntegrationTest.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ReferenceLineImporterIntegrationTest.cs" />
   </ItemGroup>