Index: Ringtoets/Common/src/Ringtoets.Common.Data/UpdateDataStrategies/UpdateDataStrategyBase.cs
===================================================================
diff -u -rdd4e75e27880fc06f6823cca424a010ab19adb33 -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Common/src/Ringtoets.Common.Data/UpdateDataStrategies/UpdateDataStrategyBase.cs	(.../UpdateDataStrategyBase.cs)	(revision dd4e75e27880fc06f6823cca424a010ab19adb33)
+++ Ringtoets/Common/src/Ringtoets.Common.Data/UpdateDataStrategies/UpdateDataStrategyBase.cs	(.../UpdateDataStrategyBase.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -67,21 +67,21 @@
         }
 
         /// <summary>
-        /// Updates the (dependent) objects with new data from the imported data.
+        /// Updates the object and its dependent data with data from the imported data.
         /// </summary>
-        /// <param name="objectsToUpdate">Objects that need to be updated.</param>
-        /// <param name="importedDataCollection">The data that was imported.</param>
+        /// <param name="objectToUpdate">Object that needs to be updated.</param>
+        /// <param name="objectToUpdateFrom">The object to update from.</param>
         /// <returns>An <see cref="IEnumerable{IObservable}"/> with affected objects.</returns>
         /// <exception cref="InvalidOperationException">Thrown when duplicate items are found.</exception>
-        protected abstract IEnumerable<IObservable> UpdateData(IEnumerable<TTargetData> objectsToUpdate,
-                                                               IEnumerable<TTargetData> importedDataCollection);
+        protected abstract IEnumerable<IObservable> UpdateObjectAndDependentData(TTargetData objectToUpdate,
+                                                                                 TTargetData objectToUpdateFrom);
 
         /// <summary>
         /// Removes the objects and their dependent data.
         /// </summary>
-        /// <param name="removedObjects">The objects that are removed.</param>
+        /// <param name="removedObject">The object that is removed.</param>
         /// <returns>An <see cref="IEnumerable{T}"/> with affected objects.</returns>
-        protected abstract IEnumerable<IObservable> RemoveData(IEnumerable<TTargetData> removedObjects);
+        protected abstract IEnumerable<IObservable> RemoveObjectAndDependentData(TTargetData removedObject);
 
         /// <summary>
         /// Updates the items and their associated data within the target collection with the data contained 
@@ -141,7 +141,7 @@
             TTargetData[] objectsToBeUpdated = GetObjectsToBeUpdated(targetDataCollection, importedObjects).ToArray();
 
             var affectedObjects = new List<IObservable>();
-            if (objectsToBeAdded.Any())
+            if (objectsToBeAdded.Any() || objectsToBeRemoved.Any())
             {
                 affectedObjects.Add(targetDataCollection);
             }
@@ -167,5 +167,42 @@
         {
             return importedDataObjects.Where(source => !existingCollection.Contains(source, equalityComparer));
         }
+
+        /// <summary>
+        /// Updates all the objects and their dependent data that needs to be updated with data from the imported data collection.
+        /// </summary>
+        /// <param name="objectsToUpdate">The objects that need to be updated.</param>
+        /// <param name="importedDataCollection">The data to update from.</param>
+        /// <returns>A <see cref="IEnumerable{T}"/> of affected items.</returns>
+        private IEnumerable<IObservable> UpdateData(IEnumerable<TTargetData> objectsToUpdate,
+                                                    IEnumerable<TTargetData> importedDataCollection)
+        {
+            var affectedObjects = new List<IObservable>();
+
+            foreach (TTargetData objectToUpdate in objectsToUpdate)
+            {
+                TTargetData objectToUpdateFrom = importedDataCollection.Single(importedObject =>
+                                                                                   equalityComparer.Equals(importedObject, objectToUpdate));
+                affectedObjects.AddRange(UpdateObjectAndDependentData(objectToUpdate, objectToUpdateFrom));
+            }
+
+            return affectedObjects;
+        }
+
+        /// <summary>
+        /// Removes all the objects and their dependent data.
+        /// </summary>
+        /// <param name="objectsToRemove">The objects that need to be removed.</param>
+        /// <returns>A <see cref="IEnumerable{T}"/> of affected items.</returns>
+        private IEnumerable<IObservable> RemoveData(IEnumerable<TTargetData> objectsToRemove)
+        {
+            var affectedObjects = new List<IObservable>();
+
+            foreach (TTargetData objectToRemove in objectsToRemove)
+            {
+                affectedObjects.AddRange(RemoveObjectAndDependentData(objectToRemove));
+            }
+            return affectedObjects;
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Common/test/Ringtoets.Common.Data.Test/UpdateDataStrategies/UpdateDataStrategyBaseTest.cs
===================================================================
diff -u -rdd4e75e27880fc06f6823cca424a010ab19adb33 -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Common/test/Ringtoets.Common.Data.Test/UpdateDataStrategies/UpdateDataStrategyBaseTest.cs	(.../UpdateDataStrategyBaseTest.cs)	(revision dd4e75e27880fc06f6823cca424a010ab19adb33)
+++ Ringtoets/Common/test/Ringtoets.Common.Data.Test/UpdateDataStrategies/UpdateDataStrategyBaseTest.cs	(.../UpdateDataStrategyBaseTest.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -147,47 +147,41 @@
             IEnumerable<IObservable> affectedObjects = strategy.ConcreteUpdateData(collection, Enumerable.Empty<TestItem>(), filePath);
 
             // Assert
-            CollectionAssert.AreEquivalent(itemsRemoved, affectedObjects);
+            IEnumerable<IObservable> expectedAffectedItems = itemsRemoved.Concat(new IObservable[]
+            {
+                collection
+            });
+            CollectionAssert.AreEquivalent(expectedAffectedItems, affectedObjects);
             CollectionAssert.IsEmpty(collection);
             Assert.AreEqual(filePath, collection.SourcePath);
         }
 
         [Test]
-        public void UpdateTargetCollectionData_Call_CallsFunctions()
-        {
-            // Setup
-            var collection = new TestUniqueItemCollection();
-
-            var strategy = new ConcreteUpdateDataStrategy(new TestFailureMechanism());
-
-            // Call
-            strategy.ConcreteUpdateData(collection, Enumerable.Empty<TestItem>(), sourceFilePath);
-
-            // Assert
-            Assert.IsTrue(strategy.IsUpdateDataCalled);
-            Assert.IsTrue(strategy.IsRemoveDataCalled);
-        }
-
-        [Test]
         public void UpdateTargetCollectionData_GetObjectsToRemoveCall_ReturnsExpectedAffectedItems()
         {
             // Setup
             var collection = new TestUniqueItemCollection();
             const string filePath = "path";
-            var expectedAffectedItems = new[]
+            var currentCollection = new[]
             {
                 new TestItem("Name A"),
                 new TestItem("Name B")
             };
-            collection.AddRange(expectedAffectedItems, filePath);
+            collection.AddRange(currentCollection, filePath);
 
             var strategy = new ConcreteUpdateDataStrategy(new TestFailureMechanism());
 
             // Call
-            IObservable[] affectedObjects = strategy.ConcreteUpdateData(collection, Enumerable.Empty<TestItem>(), filePath).ToArray();
+            IEnumerable<IObservable> affectedObjects = strategy.ConcreteUpdateData(collection, Enumerable.Empty<TestItem>(), filePath).ToArray();
 
             // Assert
-            CollectionAssert.AreEquivalent(expectedAffectedItems, affectedObjects);
+            Assert.IsTrue(strategy.IsRemoveObjectAndDependentDataCalled);
+
+            IEnumerable<IObservable> expectedAffectedObjects = currentCollection.Concat(new IObservable[]
+            {
+                collection
+            });
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
             CollectionAssert.IsEmpty(collection);
             Assert.AreEqual(filePath, collection.SourcePath);
         }
@@ -209,16 +203,17 @@
 
             var importedItems = new[]
             {
-                new TestItem("Name A"),
-                new TestItem("Name B")
+                DeepCloneTestItem(updatedItems[0]),
+                DeepCloneTestItem(updatedItems[1])
             };
 
             // Call
             IObservable[] affectedObjects = strategy.ConcreteUpdateData(collection, importedItems, filePath).ToArray();
 
             // Assert
-            IEnumerable<IObservable> expectedAffectedObjects = updatedItems.Concat(importedItems);
+            Assert.IsTrue(strategy.IsUpdateDataCalled);
 
+            IEnumerable<IObservable> expectedAffectedObjects = updatedItems.Concat(importedItems);
             CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
             CollectionAssert.AreEqual(updatedItems, collection);
             Assert.AreEqual(filePath, collection.SourcePath);
@@ -242,11 +237,10 @@
 
             // Assert
             CollectionAssert.AreEqual(importedItems, collection);
-            IEnumerable<IObservable> expectedAffectedObjects = importedItems.Concat(new IObservable[]
+            CollectionAssert.AreEquivalent(new[]
             {
                 collection
-            });
-            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
+            }, affectedObjects);
         }
 
         [Test]
@@ -296,8 +290,8 @@
 
             var importedItems = new[]
             {
-                new TestItem(itemOneName),
-                new TestItem(itemTwoName)
+                DeepCloneTestItem(currentCollection[0]),
+                DeepCloneTestItem(currentCollection[1])
             };
 
             var strategy = new ConcreteUpdateDataStrategy(new TestFailureMechanism());
@@ -310,27 +304,27 @@
             // Assert
             CollectionAssert.AreEqual(currentCollection, collection);
 
-            IEnumerable<IObservable> expectedAffectedObjects = currentCollection.Concat(importedItems);
-            CollectionAssert.AreEqual(expectedAffectedObjects, affectedObjects);
+            IEnumerable<TestItem> expectedAffectedObjects = currentCollection.Concat(importedItems);
+            CollectionAssert.AreEquivalent(expectedAffectedObjects, affectedObjects);
         }
 
         [Test]
         public void UpdateTargetCollectionData_CollectionNotEmptyAndImportedDataPartiallyOverlaps_UpdatesCollection()
         {
             // Setup
-            const string itemOneName = "Item one";
+            const string updateItemName = "Item one";
 
             var currentCollection = new[]
             {
-                new TestItem(itemOneName),
+                new TestItem(updateItemName),
                 new TestItem("Item Two")
             };
             var collection = new TestUniqueItemCollection();
             collection.AddRange(currentCollection, sourceFilePath);
 
             var importedItems = new[]
             {
-                new TestItem(itemOneName),
+                DeepCloneTestItem(currentCollection[0]),
                 new TestItem("Item Four")
             };
 
@@ -354,8 +348,7 @@
                 collection,
                 currentCollection[0],
                 currentCollection[1],
-                importedItems[0],
-                importedItems[1]
+                importedItems[0]
             };
             CollectionAssert.AreEquivalent(expectedAffectedItems, affectedObjects);
         }
@@ -387,8 +380,7 @@
 
             // Assert
             CollectionAssert.AreEqual(importedItems, collection);
-            IEnumerable<IObservable> expectedAffectedObjects = currentCollection.Concat(importedItems)
-                                                                                .Concat(new IObservable[]
+            IEnumerable<IObservable> expectedAffectedObjects = currentCollection                                                                                .Concat(new IObservable[]
                                                                                 {
                                                                                     collection
                                                                                 });
@@ -440,7 +432,7 @@
                 : base(failureMechanism, new NameComparer()) {}
 
             public bool IsUpdateDataCalled { get; private set; }
-            public bool IsRemoveDataCalled { get; private set; }
+            public bool IsRemoveObjectAndDependentDataCalled { get; private set; }
 
             public IEnumerable<IObservable> ConcreteUpdateData(ObservableUniqueItemCollectionWithSourcePath<TestItem> targetCollection,
                                                                IEnumerable<TestItem> importedDataCollection,
@@ -449,22 +441,25 @@
                 return UpdateTargetCollectionData(targetCollection, importedDataCollection, sourceFilePath);
             }
 
-            protected override IEnumerable<IObservable> UpdateData(IEnumerable<TestItem> objectsToUpdate, IEnumerable<TestItem> importedDataCollection)
+            protected override IEnumerable<IObservable> UpdateObjectAndDependentData(TestItem objectToUpdate, TestItem objectToUpdateFrom)
             {
                 IsUpdateDataCalled = true;
-                var affectedObjects = new List<IObservable>();
-                affectedObjects.AddRange(objectsToUpdate);
-                affectedObjects.AddRange(importedDataCollection);
-                return affectedObjects;
+
+                return new []
+                {
+                    objectToUpdate,
+                    objectToUpdateFrom
+                };
             }
 
-            protected override IEnumerable<IObservable> RemoveData(IEnumerable<TestItem> removedObjects)
+            protected override IEnumerable<IObservable> RemoveObjectAndDependentData(TestItem removedObject)
             {
-                IsRemoveDataCalled = true;
+                IsRemoveObjectAndDependentDataCalled = true;
 
-                var affectedObjects = new List<IObservable>();
-                affectedObjects.AddRange(removedObjects);
-                return affectedObjects;
+                return new []
+                {
+                    removedObject
+                };
             }
 
             private class NameComparer : IEqualityComparer<TestItem>
@@ -500,5 +495,11 @@
                 return Name;
             }
         }
+
+        private static TestItem DeepCloneTestItem(TestItem item)
+        {
+            var newItem = new TestItem(item.Name);
+            return newItem;
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/RingtoetsPipingSurfaceLineUpdateStrategy.cs
===================================================================
diff -u -rdd4e75e27880fc06f6823cca424a010ab19adb33 -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/RingtoetsPipingSurfaceLineUpdateStrategy.cs	(.../RingtoetsPipingSurfaceLineUpdateStrategy.cs)	(revision dd4e75e27880fc06f6823cca424a010ab19adb33)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/RingtoetsPipingSurfaceLineUpdateStrategy.cs	(.../RingtoetsPipingSurfaceLineUpdateStrategy.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -90,22 +90,17 @@
 
         #region Updating Data Functions
 
-        protected override IEnumerable<IObservable> UpdateData(IEnumerable<RingtoetsPipingSurfaceLine> objectsToUpdate,
-                                                               IEnumerable<RingtoetsPipingSurfaceLine> importedDataCollection)
+        protected override IEnumerable<IObservable> UpdateObjectAndDependentData(RingtoetsPipingSurfaceLine surfaceLineToUpdate,
+                                                                                 RingtoetsPipingSurfaceLine matchingSurfaceLine)
         {
             var affectedObjects = new List<IObservable>();
 
-            foreach (RingtoetsPipingSurfaceLine updatedSurfaceLine in objectsToUpdate)
+            if (!surfaceLineToUpdate.Equals(matchingSurfaceLine))
             {
-                RingtoetsPipingSurfaceLine matchingSurfaceLine = importedDataCollection.Single(sl => sl.Name == updatedSurfaceLine.Name);
+                surfaceLineToUpdate.Update(matchingSurfaceLine);
 
-                if (!updatedSurfaceLine.Equals(matchingSurfaceLine))
-                {
-                    updatedSurfaceLine.Update(matchingSurfaceLine);
-
-                    affectedObjects.AddRange(UpdateSurfaceLineDependentData(updatedSurfaceLine));
-                    affectedObjects.AddRange(UpdateStochasticSoilModel(updatedSurfaceLine));
-                }
+                affectedObjects.AddRange(UpdateSurfaceLineDependentData(surfaceLineToUpdate));
+                affectedObjects.AddRange(UpdateStochasticSoilModel(surfaceLineToUpdate));
             }
 
             return affectedObjects;
@@ -162,22 +157,11 @@
 
         #region Removing Data Functions
 
-        protected override IEnumerable<IObservable> RemoveData(IEnumerable<RingtoetsPipingSurfaceLine> removedObjects)
+        protected override IEnumerable<IObservable> RemoveObjectAndDependentData(RingtoetsPipingSurfaceLine removedSurfaceLine)
         {
-            var affectedObjects = new List<IObservable>();
-
-            foreach (RingtoetsPipingSurfaceLine surfaceLine in removedObjects)
-            {
-                affectedObjects.AddRange(ClearSurfaceLineDependentData(surfaceLine));
-            }
-            return affectedObjects;
+            return PipingDataSynchronizationService.RemoveSurfaceLine(failureMechanism, removedSurfaceLine);
         }
 
-        private IEnumerable<IObservable> ClearSurfaceLineDependentData(RingtoetsPipingSurfaceLine surfaceLine)
-        {
-            return PipingDataSynchronizationService.RemoveSurfaceLine(failureMechanism, surfaceLine);
-        }
-
         #endregion
     }
 }
\ No newline at end of file
Index: Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/StochasticSoilModelUpdateDataStrategy.cs
===================================================================
diff -u -r7172df944db7fd2d59d68a7a8def96110a44ed9b -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/StochasticSoilModelUpdateDataStrategy.cs	(.../StochasticSoilModelUpdateDataStrategy.cs)	(revision 7172df944db7fd2d59d68a7a8def96110a44ed9b)
+++ Ringtoets/Piping/src/Ringtoets.Piping.Plugin/FileImporter/StochasticSoilModelUpdateDataStrategy.cs	(.../StochasticSoilModelUpdateDataStrategy.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -89,28 +89,25 @@
 
         #region Update Data Functions
 
-        protected override IEnumerable<IObservable> UpdateData(IEnumerable<StochasticSoilModel> objectsToUpdate,
-                                                               IEnumerable<StochasticSoilModel> importedDataCollection)
+        protected override IEnumerable<IObservable> UpdateObjectAndDependentData(StochasticSoilModel soilModelToUpdate,
+                                                                                 StochasticSoilModel soilModelToUpdateFrom)
         {
             var affectedObjects = new List<IObservable>();
-            foreach (StochasticSoilModel updatedModel in objectsToUpdate)
-            {
-                affectedObjects.Add(updatedModel);
-                StochasticSoilModel readModel = importedDataCollection.Single(r => r.Name.Equals(updatedModel.Name));
-                affectedObjects.AddRange(UpdateStochasticSoilModel(updatedModel, readModel));
-            }
+            affectedObjects.AddRange(UpdateStochasticSoilModel(soilModelToUpdate, soilModelToUpdateFrom));
+
             return affectedObjects;
         }
 
-        private IEnumerable<IObservable> UpdateStochasticSoilModel(StochasticSoilModel existingModel, StochasticSoilModel readModel)
+        private IEnumerable<IObservable> UpdateStochasticSoilModel(StochasticSoilModel modelToUpdate, StochasticSoilModel modelToUpdateFrom)
         {
-            Dictionary<StochasticSoilProfile, PipingSoilProfile> oldProfiles = existingModel
+            Dictionary<StochasticSoilProfile, PipingSoilProfile> oldProfiles = modelToUpdate
                 .StochasticSoilProfiles
                 .ToDictionary(ssp => ssp, ssp => ssp.SoilProfile, new ReferenceEqualityComparer<StochasticSoilProfile>());
 
-            StochasticSoilModelProfileDifference difference = existingModel.Update(readModel);
+            StochasticSoilModelProfileDifference difference = modelToUpdate.Update(modelToUpdateFrom);
 
             var affectedObjects = new List<IObservable>();
+            affectedObjects.Add(modelToUpdate);
             foreach (StochasticSoilProfile removedProfile in difference.RemovedProfiles)
             {
                 affectedObjects.AddRange(PipingDataSynchronizationService.RemoveStochasticSoilProfileFromInput(failureMechanism, removedProfile));
@@ -130,19 +127,8 @@
 
         #region Remove Data Functions
 
-        protected override IEnumerable<IObservable> RemoveData(IEnumerable<StochasticSoilModel> removedObjects)
+        protected override IEnumerable<IObservable> RemoveObjectAndDependentData(StochasticSoilModel removedModel)
         {
-            var affectedObjects = new List<IObservable>();
-
-            foreach (StochasticSoilModel model in removedObjects)
-            {
-                affectedObjects.AddRange(ClearStochasticSoilModelDependentData(model));
-            }
-            return affectedObjects;
-        }
-
-        private IEnumerable<IObservable> ClearStochasticSoilModelDependentData(StochasticSoilModel removedModel)
-        {
             return PipingDataSynchronizationService.RemoveStochasticSoilModel(failureMechanism, removedModel);
         }
 
Index: Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/RingtoetsPipingSurfaceLineUpdateDataStrategyTest.cs
===================================================================
diff -u -rdd4e75e27880fc06f6823cca424a010ab19adb33 -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/RingtoetsPipingSurfaceLineUpdateDataStrategyTest.cs	(.../RingtoetsPipingSurfaceLineUpdateDataStrategyTest.cs)	(revision dd4e75e27880fc06f6823cca424a010ab19adb33)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/RingtoetsPipingSurfaceLineUpdateDataStrategyTest.cs	(.../RingtoetsPipingSurfaceLineUpdateDataStrategyTest.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -264,28 +264,30 @@
         public void UpdateSurfaceLinesWithImportedData_WithCurrentLinesAndImportedDataEmpty_SurfaceLinesRemoved()
         {
             // Setup
-            var targetCollection = new RingtoetsPipingSurfaceLineCollection();
             const string collectionSurfaceLineName = "Name A";
-            targetCollection.AddRange(new[]
+
+            var failureMechanism = new PipingFailureMechanism();
+            RingtoetsPipingSurfaceLineCollection surfaceLineCollection = failureMechanism.SurfaceLines;
+            surfaceLineCollection.AddRange(new[]
             {
                 new RingtoetsPipingSurfaceLine
                 {
                     Name = collectionSurfaceLineName
                 }
             }, sourceFilePath);
 
-            var strategy = new RingtoetsPipingSurfaceLineUpdateDataStrategy(new PipingFailureMechanism());
+            var strategy = new RingtoetsPipingSurfaceLineUpdateDataStrategy(failureMechanism);
 
             // Call
-            IEnumerable<IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(targetCollection,
+            IEnumerable<IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(surfaceLineCollection,
                                                                                                    Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
                                                                                                    sourceFilePath);
 
             // Assert
-            CollectionAssert.IsEmpty(targetCollection);
+            CollectionAssert.IsEmpty(surfaceLineCollection);
             CollectionAssert.AreEqual(new[]
             {
-                targetCollection
+                surfaceLineCollection
             }, affectedObjects);
         }
 
@@ -453,17 +455,16 @@
 
             var failureMechanism = new PipingFailureMechanism();
             failureMechanism.CalculationsGroup.Children.Add(calculation);
-
-            var strategy = new RingtoetsPipingSurfaceLineUpdateDataStrategy(failureMechanism);
-
-            var collection = new RingtoetsPipingSurfaceLineCollection();
-            collection.AddRange(new[]
-            {
+            RingtoetsPipingSurfaceLineCollection surfaceLineCollection = failureMechanism.SurfaceLines;
+            surfaceLineCollection.AddRange(new[]
+{
                 surfaceLine
             }, sourceFilePath);
 
+            var strategy = new RingtoetsPipingSurfaceLineUpdateDataStrategy(failureMechanism);
+            
             // Call
-            IEnumerable<IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(collection,
+            IEnumerable<IObservable> affectedObjects = strategy.UpdateSurfaceLinesWithImportedData(surfaceLineCollection,
                                                                                                    Enumerable.Empty<RingtoetsPipingSurfaceLine>(),
                                                                                                    sourceFilePath).ToArray();
 
@@ -472,7 +473,7 @@
             Assert.IsNull(calculation.InputParameters.SurfaceLine);
             CollectionAssert.AreEquivalent(new IObservable[]
             {
-                collection,
+                surfaceLineCollection,
                 calculation,
                 calculation.InputParameters
             }, affectedObjects);
Index: Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/StochasticSoilModelUpdateDataStrategyTest.cs
===================================================================
diff -u -r7172df944db7fd2d59d68a7a8def96110a44ed9b -r85b53922d59e2d43ef299322b89e0de7ea085c63
--- Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/StochasticSoilModelUpdateDataStrategyTest.cs	(.../StochasticSoilModelUpdateDataStrategyTest.cs)	(revision 7172df944db7fd2d59d68a7a8def96110a44ed9b)
+++ Ringtoets/Piping/test/Ringtoets.Piping.Plugin.Test/FileImporter/StochasticSoilModelUpdateDataStrategyTest.cs	(.../StochasticSoilModelUpdateDataStrategyTest.cs)	(revision 85b53922d59e2d43ef299322b89e0de7ea085c63)
@@ -185,23 +185,26 @@
         public void UpdateModelWithImportedData_WithCurrentModelsAndImportedDataEmpty_ModelsRemoved()
         {
             // Setup
-            var targetCollection = new StochasticSoilModelCollection();
-            targetCollection.AddRange(new[]
+            var failureMechanism = new PipingFailureMechanism();
+            StochasticSoilModelCollection stochasticSoilModelCollection = failureMechanism.StochasticSoilModels;
+            stochasticSoilModelCollection.AddRange(new[]
             {
                 new TestStochasticSoilModel("A"),
                 new TestStochasticSoilModel("B")
             }, sourceFilePath);
 
-            var strategy = new StochasticSoilModelUpdateDataStrategy(new PipingFailureMechanism());
+            var strategy = new StochasticSoilModelUpdateDataStrategy(failureMechanism);
 
             // Call
-            IEnumerable<IObservable> affectedObjects = strategy.UpdateModelWithImportedData(targetCollection, new List<StochasticSoilModel>(), sourceFilePath);
+            IEnumerable<IObservable> affectedObjects = strategy.UpdateModelWithImportedData(stochasticSoilModelCollection,
+                                                                                            new List<StochasticSoilModel>(),
+                                                                                            sourceFilePath);
 
             // Assert
-            CollectionAssert.IsEmpty(targetCollection);
-            CollectionAssert.AreEqual(new[]
+            CollectionAssert.IsEmpty(stochasticSoilModelCollection);
+            CollectionAssert.AreEquivalent(new[]
             {
-                targetCollection
+                stochasticSoilModelCollection
             }, affectedObjects);
         }
 
@@ -425,25 +428,24 @@
 
             var failureMechanism = new PipingFailureMechanism();
             failureMechanism.CalculationsGroup.Children.Add(calculation);
-
-            var strategy = new StochasticSoilModelUpdateDataStrategy(failureMechanism);
-
-            var targetCollection = new StochasticSoilModelCollection();
-            targetCollection.AddRange(new[]
+            StochasticSoilModelCollection stochasticSoilModelCollection = failureMechanism.StochasticSoilModels;
+            stochasticSoilModelCollection.AddRange(new[]
             {
                 existingModel
             }, sourceFilePath);
 
+            var strategy = new StochasticSoilModelUpdateDataStrategy(failureMechanism);
+
             // Call
-            IEnumerable<IObservable> affectedObjects = strategy.UpdateModelWithImportedData(targetCollection, new List<StochasticSoilModel>(), sourceFilePath).ToArray();
+            IEnumerable<IObservable> affectedObjects = strategy.UpdateModelWithImportedData(stochasticSoilModelCollection, new List<StochasticSoilModel>(), sourceFilePath).ToArray();
 
             // Assert
             Assert.IsFalse(calculation.HasOutput);
             Assert.IsNull(calculation.InputParameters.StochasticSoilModel);
             Assert.IsNull(calculation.InputParameters.StochasticSoilProfile);
             CollectionAssert.AreEquivalent(new IObservable[]
             {
-                targetCollection,
+                stochasticSoilModelCollection,
                 calculation,
                 calculation.InputParameters
             }, affectedObjects);