Fisheye: Tag d82ab38fadcd577385b43e5951c2f4ace3180275 refers to a dead (removed) revision in file `Ringtoets/Integration/src/Ringtoets.Integration.Plugin/AssessmentSectionMerger.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs
===================================================================
diff -u -rc6a4d30d199c04d78fed44e0ab315f4a319d93b2 -rd82ab38fadcd577385b43e5951c2f4ace3180275
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs	(.../AssessmentSectionMerger.cs)	(revision c6a4d30d199c04d78fed44e0ab315f4a319d93b2)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Merge/AssessmentSectionMerger.cs	(.../AssessmentSectionMerger.cs)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
@@ -27,6 +27,7 @@
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Data.Merge;
 using Ringtoets.Integration.Forms.Merge;
+using Ringtoets.Integration.Plugin.Handlers;
 using Ringtoets.Integration.Plugin.Properties;
 using Ringtoets.Integration.Service.Comparers;
 using CoreCommonGuiResources = Core.Common.Gui.Properties.Resources;
@@ -41,36 +42,37 @@
         private static readonly ILog log = LogManager.GetLogger(typeof(AssessmentSectionMerger));
 
         private readonly IAssessmentSectionMergeFilePathProvider filePathProvider;
-        private readonly IAssessmentSectionProvider assessmentSectionProvider;
-        private readonly IAssessmentSectionMergeComparer mergeComparer;
-        private readonly IAssessmentSectionMergeDataProvider mergeDataProvider;
+        private readonly Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction;
+        private readonly IAssessmentSectionMergeComparer comparer;
+        private readonly IMergeDataProvider mergeDataProvider;
         private readonly IAssessmentSectionMergeHandler mergeHandler;
 
         /// <summary>
-        /// Creates a new instance of <see cref="AssessmentSectionMerger"/>.
+        /// Creates a new instance of <see cref="AssessmentSectionMerger"/>,
         /// </summary>
         /// <param name="filePathProvider">The provider to get the file path of the file to merge.</param>
-        /// <param name="assessmentSectionProvider">The provider to the assessment sections to merge.</param>
-        /// <param name="mergeComparer">The comparer to compare the assessment sections with.</param>
+        /// <param name="getAssessmentSectionsAction">The action for getting the assessment sections
+        /// to merge.</param>
+        /// <param name="comparer">The comparer to compare the assessment sections with.</param>
         /// <param name="mergeDataProvider">The provider to get the data to merge from.</param>
         /// <param name="mergeHandler">The handler to perform the merge.</param>
         /// <exception cref="ArgumentNullException">Thrown when any parameter is <c>null</c>.</exception>
-        public AssessmentSectionMerger(IAssessmentSectionMergeFilePathProvider filePathProvider, IAssessmentSectionProvider assessmentSectionProvider,
-                                       IAssessmentSectionMergeComparer mergeComparer, IAssessmentSectionMergeDataProvider mergeDataProvider, IAssessmentSectionMergeHandler mergeHandler)
+        public AssessmentSectionMerger(IAssessmentSectionMergeFilePathProvider filePathProvider, Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction,
+                                       IAssessmentSectionMergeComparer comparer, IMergeDataProvider mergeDataProvider, IAssessmentSectionMergeHandler mergeHandler)
         {
             if (filePathProvider == null)
             {
                 throw new ArgumentNullException(nameof(filePathProvider));
             }
 
-            if (assessmentSectionProvider == null)
+            if (getAssessmentSectionsAction == null)
             {
-                throw new ArgumentNullException(nameof(assessmentSectionProvider));
+                throw new ArgumentNullException(nameof(getAssessmentSectionsAction));
             }
 
-            if (mergeComparer == null)
+            if (comparer == null)
             {
-                throw new ArgumentNullException(nameof(mergeComparer));
+                throw new ArgumentNullException(nameof(comparer));
             }
 
             if (mergeDataProvider == null)
@@ -84,8 +86,8 @@
             }
 
             this.filePathProvider = filePathProvider;
-            this.assessmentSectionProvider = assessmentSectionProvider;
-            this.mergeComparer = mergeComparer;
+            this.getAssessmentSectionsAction = getAssessmentSectionsAction;
+            this.comparer = comparer;
             this.mergeDataProvider = mergeDataProvider;
             this.mergeHandler = mergeHandler;
         }
@@ -111,61 +113,77 @@
                 return;
             }
 
-            IEnumerable<AssessmentSection> assessmentSections;
+            IEnumerable<AssessmentSection> assessmentSections = GetAssessmentSections(filePath);
 
-            try
+            if (assessmentSections == null)
             {
-                assessmentSections = assessmentSectionProvider.GetAssessmentSections(filePath);
-            }
-            catch (AssessmentSectionProviderException)
-            {
                 return;
             }
 
             if (!assessmentSections.Any())
             {
-                log.Error(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
+                LogError(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
                 return;
             }
 
-            IEnumerable<AssessmentSection> matchingAssessmentSections = assessmentSections.Where(section => mergeComparer.Compare(assessmentSection, section));
+            IEnumerable<AssessmentSection> matchingAssessmentSections = assessmentSections.Where(section => comparer.Compare(assessmentSection, section));
 
             if (!matchingAssessmentSections.Any())
             {
-                log.Error(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
+                LogError(Resources.AssessmentSectionMerger_No_matching_AssessmentSections);
                 return;
             }
 
-            AssessmentSectionMergeData mergeData = mergeDataProvider.GetMergeData(matchingAssessmentSections);
-
-            if (mergeData == null)
+            if (!mergeDataProvider.SelectData(matchingAssessmentSections))
             {
                 LogCancelMessage();
                 return;
             }
 
-            PerformMerge(assessmentSection, mergeData.AssessmentSection, mergeData.FailureMechanisms);
+            AssessmentSection assessmentSectionToMerge = mergeDataProvider.SelectedAssessmentSection;
+            IEnumerable<IFailureMechanism> failureMechanismToMerge = mergeDataProvider.SelectedFailureMechanisms;
+
+            if (assessmentSectionToMerge == null || failureMechanismToMerge == null)
+            {
+                LogError(Resources.AssessmentSectionMerger_No_AssessmentSection_selected);
+                return;
+            }
+
+            PerformMerge(assessmentSection, assessmentSectionToMerge, failureMechanismToMerge);
         }
 
+        private IEnumerable<AssessmentSection> GetAssessmentSections(string filePath)
+        {
+            var assessmentSectionsOwner = new AssessmentSectionsOwner();
+            getAssessmentSectionsAction(filePath, assessmentSectionsOwner);
+            return assessmentSectionsOwner.AssessmentSections;
+        }
+
         private void PerformMerge(AssessmentSection assessmentSection, AssessmentSection assessmentSectionToMerge, IEnumerable<IFailureMechanism> failureMechanismToMerge)
         {
-            log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_started);
+            log.InfoFormat(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSection_0_with_AssessmentSection_1_started,
+                           assessmentSectionToMerge.Name, assessmentSection.Name);
 
             try
             {
                 mergeHandler.PerformMerge(assessmentSection, assessmentSectionToMerge, failureMechanismToMerge);
-                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_successful);
+                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_assessmentSections_successful);
             }
             catch (Exception e)
             {
-                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Unexpected_error_occurred_during_merge, e);
-                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Merging_AssessmentSections_failed);
+                log.Error(Resources.AssessmentSectionMerger_PerformMerge_Unexpected_error_occurred_during_merging, e);
+                log.Info(Resources.AssessmentSectionMerger_PerformMerge_Merging_assessmentSections_failed);
             }
         }
 
         private static void LogCancelMessage()
         {
-            log.Warn(CoreCommonGuiResources.GuiImportHandler_ImportItemsUsingDialog_Importing_cancelled);
+            log.Info(CoreCommonGuiResources.GuiImportHandler_ImportItemsUsingDialog_Importing_cancelled);
         }
+
+        private static void LogError(string message)
+        {
+            log.Error(message);
+        }
     }
 }
\ No newline at end of file
Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj
===================================================================
diff -u -r61749a95649b845b5705ea40825b5f4257d38ed5 -rd82ab38fadcd577385b43e5951c2f4ace3180275
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj	(.../Ringtoets.Integration.Plugin.csproj)	(revision 61749a95649b845b5705ea40825b5f4257d38ed5)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/Ringtoets.Integration.Plugin.csproj	(.../Ringtoets.Integration.Plugin.csproj)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
@@ -25,7 +25,7 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AssessmentSectionMerger.cs" />
+    <Compile Include="Merge\AssessmentSectionMerger.cs" />
     <Compile Include="FileImporters\ForeshoreProfileReplaceDataStrategy.cs" />
     <Compile Include="FileImporters\ForeshoreProfileUpdateDataStrategy.cs" />
     <Compile Include="Handlers\AssessmentSectionCompositionChangeHandler.cs" />
Index: Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs
===================================================================
diff -u -r15c1d2fdc2e70b1d921cfb607ee2f650e69e42a2 -rd82ab38fadcd577385b43e5951c2f4ace3180275
--- Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs	(.../RingtoetsPlugin.cs)	(revision 15c1d2fdc2e70b1d921cfb607ee2f650e69e42a2)
+++ Ringtoets/Integration/src/Ringtoets.Integration.Plugin/RingtoetsPlugin.cs	(.../RingtoetsPlugin.cs)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
@@ -90,6 +90,7 @@
 using Ringtoets.Integration.IO.Exporters;
 using Ringtoets.Integration.Plugin.FileImporters;
 using Ringtoets.Integration.Plugin.Handlers;
+using Ringtoets.Integration.Plugin.Merge;
 using Ringtoets.Integration.Plugin.Properties;
 using Ringtoets.Integration.Service;
 using Ringtoets.Integration.Service.Comparers;
Fisheye: Tag d82ab38fadcd577385b43e5951c2f4ace3180275 refers to a dead (removed) revision in file `Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/AssessmentSectionMergerTest.cs'.
Fisheye: No comparison available.  Pass `N' to diff?
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergerTest.cs
===================================================================
diff -u -rc6a4d30d199c04d78fed44e0ab315f4a319d93b2 -rd82ab38fadcd577385b43e5951c2f4ace3180275
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergerTest.cs	(.../AssessmentSectionMergerTest.cs)	(revision c6a4d30d199c04d78fed44e0ab315f4a319d93b2)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Merge/AssessmentSectionMergerTest.cs	(.../AssessmentSectionMergerTest.cs)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
@@ -30,6 +30,7 @@
 using Ringtoets.Integration.Data;
 using Ringtoets.Integration.Data.Merge;
 using Ringtoets.Integration.Forms.Merge;
+using Ringtoets.Integration.Plugin.Handlers;
 using Ringtoets.Integration.Plugin.Merge;
 using Ringtoets.Integration.Service.Comparers;
 
@@ -43,14 +44,13 @@
         {
             // Setup
             var mocks = new MockRepository();
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => new AssessmentSectionMerger(null, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            TestDelegate call = () => new AssessmentSectionMerger(null, (path, owner) => {}, comparer, mergeDataProvider, mergeHandler);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -59,13 +59,13 @@
         }
 
         [Test]
-        public void Constructor_AssessmentSectionProvider_ThrowsArgumentNullException()
+        public void Constructor_GetAssessmentSectionsActionNull_ThrowsArgumentNullException()
         {
             // Setup
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
@@ -74,27 +74,26 @@
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("assessmentSectionProvider", exception.ParamName);
+            Assert.AreEqual("getAssessmentSectionsAction", exception.ParamName);
             mocks.VerifyAll();
         }
 
         [Test]
-        public void Constructor_MergeComparerNull_ThrowsArgumentNullException()
+        public void Constructor_ComparerNull_ThrowsArgumentNullException()
         {
             // Setup
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, null, mergeDataProvider, mergeHandler);
+            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, null, mergeDataProvider, mergeHandler);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
-            Assert.AreEqual("mergeComparer", exception.ParamName);
+            Assert.AreEqual("comparer", exception.ParamName);
             mocks.VerifyAll();
         }
 
@@ -104,13 +103,12 @@
             // Setup
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, null, mergeHandler);
+            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, comparer, null, mergeHandler);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -124,13 +122,12 @@
             // Setup
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             mocks.ReplayAll();
 
             // Call
-            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, null);
+            TestDelegate call = () => new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, comparer, mergeDataProvider, null);
 
             // Assert
             var exception = Assert.Throws<ArgumentNullException>(call);
@@ -144,13 +141,12 @@
             // Setup
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            var merger = new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, comparer, mergeDataProvider, mergeHandler);
 
             // Call
             TestDelegate call = () => merger.StartMerge(null);
@@ -168,38 +164,34 @@
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(null);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            var merger = new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, comparer, mergeDataProvider, mergeHandler);
 
             // Call
             Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
 
             // Assert
-            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Importeren van gegevens is geannuleerd.", LogLevelConstant.Warn), 1);
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Importeren van gegevens is geannuleerd.", LogLevelConstant.Info), 1);
             mocks.VerifyAll();
         }
 
         [Test]
-        public void GivenValidFilePath_WhenAssessmentSectionProviderThrowsAssessmentSectionProviderException_ThenAbort()
+        public void GivenValidFilePath_WhenGetAssessmentSectionActionReturnNull_ThenAbort()
         {
             // Given
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(null)).IgnoreArguments()
-                                     .Throw(new AssessmentSectionProviderException());
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            var merger = new AssessmentSectionMerger(filePathProvider, (path, owner) => {}, comparer, mergeDataProvider, mergeHandler);
 
             // When
             Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
@@ -210,22 +202,21 @@
         }
 
         [Test]
-        public void GivenValidFilePath_WhenAssessmentSectionProviderReturnsEmptyCollection_ThenLogErrorAndAbort()
+        public void GivenValidFilePath_WhenAssessmentSectionProviderReturnEmptyCollection_ThenLogErrorAndAbort()
         {
             // Given
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(null)).IgnoreArguments()
-                                     .Return(Enumerable.Empty<AssessmentSection>());
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) => { owner.AssessmentSections = Enumerable.Empty<AssessmentSection>(); };
 
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
             // When
             Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
 
@@ -235,26 +226,28 @@
         }
 
         [Test]
-        public void GivenAssessmentSection_WhenComparerReturnsFalse_ThenLogErrorAndAbort()
+        public void GivenAssessmentSection_WhenComparerReturnFalse_ThenLogErrorAndAbort()
         {
             // Given
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(null)).IgnoreArguments()
-                                     .Return(new[]
-                                     {
-                                         new AssessmentSection(AssessmentSectionComposition.Dike)
-                                     });
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
             comparer.Expect(c => c.Compare(null, null)).IgnoreArguments().Return(false);
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    new AssessmentSection(AssessmentSectionComposition.Dike)
+                };
+            };
 
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
             // When
             Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
 
@@ -264,40 +257,109 @@
         }
 
         [Test]
-        public void GivenMatchedAssessmentSection_WhenMergeDataProviderReturnsNull_ThenLogCancelMessageAndAbort()
+        public void GivenMatchedAssessmentSection_WhenMergeDataProviderReturnFalse_ThenLogCancelMessageAndAbort()
         {
             // Given
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(null)).IgnoreArguments()
-                                     .Return(new[]
-                                     {
-                                         new AssessmentSection(AssessmentSectionComposition.Dike)
-                                     });
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
             comparer.Expect(c => c.Compare(null, null)).IgnoreArguments().Return(true);
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
-            mergeDataProvider.Expect(mdp => mdp.GetMergeData(null)).IgnoreArguments().Return(null);
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
+            mergeDataProvider.Expect(mdp => mdp.SelectData(null)).IgnoreArguments().Return(false);
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    new AssessmentSection(AssessmentSectionComposition.Dike)
+                };
+            };
 
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
             // When
             Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
 
             // Then
-            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Importeren van gegevens is geannuleerd.", LogLevelConstant.Warn), 1);
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Importeren van gegevens is geannuleerd.", LogLevelConstant.Info), 1);
             mocks.VerifyAll();
         }
 
         [Test]
+        public void GivenMatchedAssessmentSection_WhenMergeDataProviderReturnTrueButSelectedAssessmentSectionNull_ThenLogErrorMessageAndAbort()
+        {
+            // Given
+            var mocks = new MockRepository();
+            var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
+            filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
+            var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
+            comparer.Expect(c => c.Compare(null, null)).IgnoreArguments().Return(true);
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
+            mergeDataProvider.Expect(mdp => mdp.SelectData(null)).IgnoreArguments().Return(true);
+            mergeDataProvider.Expect(mdp => mdp.SelectedAssessmentSection).Return(null);
+            mergeDataProvider.Expect(mdp => mdp.SelectedFailureMechanisms).Return(Enumerable.Empty<IFailureMechanism>());
+            var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
+            mocks.ReplayAll();
+
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    new AssessmentSection(AssessmentSectionComposition.Dike)
+                };
+            };
+
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
+            // When
+            Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
+
+            // Then
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Er is geen traject geselecteerd.", LogLevelConstant.Error), 1);
+            mocks.VerifyAll();
+        }
+
+        [Test]
+        public void GivenMatchedAssessmentSection_WhenMergeDataProviderReturnTrueButSelectedFailureMechanismsNull_ThenLogErrorMessageAndAbort()
+        {
+            // Given
+            var mocks = new MockRepository();
+            var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
+            filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
+            var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
+            comparer.Expect(c => c.Compare(null, null)).IgnoreArguments().Return(true);
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
+            mergeDataProvider.Expect(mdp => mdp.SelectData(null)).IgnoreArguments().Return(true);
+            mergeDataProvider.Expect(mdp => mdp.SelectedAssessmentSection).Return(new AssessmentSection(AssessmentSectionComposition.Dike));
+            mergeDataProvider.Expect(mdp => mdp.SelectedFailureMechanisms).Return(null);
+            var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
+            mocks.ReplayAll();
+
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    new AssessmentSection(AssessmentSectionComposition.Dike)
+                };
+            };
+
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
+            // When
+            Action call = () => merger.StartMerge(new AssessmentSection(AssessmentSectionComposition.Dike));
+
+            // Then
+            TestHelper.AssertLogMessageWithLevelIsGenerated(call, new Tuple<string, LogLevelConstant>("Er is geen traject geselecteerd.", LogLevelConstant.Error), 1);
+            mocks.VerifyAll();
+        }
+
+        [Test]
         public void GivenMatchedAssessmentSection_WhenAllDataValid_ThenMergePerformedAndLogged()
         {
             // Given
-            var filePath = "Filepath";
             var originalAssessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
             var assessmentSectionToMerge = new AssessmentSection(AssessmentSectionComposition.Dike);
             var failureMechanismsToMerge = new IFailureMechanism[]
@@ -307,38 +369,43 @@
 
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
-            filePathProvider.Expect(helper => helper.GetFilePath()).Return(filePath);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(filePath))
-                                     .Return(new[]
-                                     {
-                                         assessmentSectionToMerge
-                                     });
+            filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
             comparer.Expect(c => c.Compare(originalAssessmentSection, assessmentSectionToMerge)).Return(true);
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
-            mergeDataProvider.Expect(mdp => mdp.GetMergeData(null)).IgnoreArguments().Return(
-                new AssessmentSectionMergeData(assessmentSectionToMerge, failureMechanismsToMerge));
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
+            mergeDataProvider.Expect(mdp => mdp.SelectData(null)).IgnoreArguments().Return(true);
+            mergeDataProvider.Expect(mdp => mdp.SelectedAssessmentSection).Return(assessmentSectionToMerge);
+            mergeDataProvider.Expect(mdp => mdp.SelectedFailureMechanisms).Return(failureMechanismsToMerge);
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mergeHandler.Expect(mh => mh.PerformMerge(originalAssessmentSection, assessmentSectionToMerge, failureMechanismsToMerge));
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    assessmentSectionToMerge
+                };
+            };
 
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
             // When
             Action call = () => merger.StartMerge(originalAssessmentSection);
 
             // Then
-            TestHelper.AssertLogMessagesWithLevelAreGenerated(call, new[]
+            TestHelper.AssertLogMessages(call, messages =>
             {
-                new Tuple<string, LogLevelConstant>("Samenvoegen van trajectinformatie is gestart.", LogLevelConstant.Info),
-                new Tuple<string, LogLevelConstant>("Samenvoegen van trajectinformatie is gelukt.", LogLevelConstant.Info)
+                string[] msgs = messages.ToArray();
+                Assert.AreEqual(2, msgs.Length);
+                Assert.AreEqual($"Samenvoegen van traject {assessmentSectionToMerge.Name} met traject {originalAssessmentSection.Name} is gestart.", msgs[0]);
+                Assert.AreEqual("Samenvoegen van trajecten is gelukt.", msgs[1]);
             });
             mocks.VerifyAll();
         }
 
         [Test]
-        public void GivenMatchedAssessmentSection_WhenMergeHandlerThrowsException_ThenMergeFailedAndLogged()
+        public void GivenMatchedAssessmentSection_WhenMergerThrowsException_ThenMergeFailedAndLogged()
         {
             // Given
             var originalAssessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
@@ -351,23 +418,26 @@
             var mocks = new MockRepository();
             var filePathProvider = mocks.StrictMock<IAssessmentSectionMergeFilePathProvider>();
             filePathProvider.Expect(helper => helper.GetFilePath()).Return(string.Empty);
-            var assessmentSectionProvider = mocks.StrictMock<IAssessmentSectionProvider>();
-            assessmentSectionProvider.Expect(asp => asp.GetAssessmentSections(null)).IgnoreArguments()
-                                     .Return(new[]
-                                     {
-                                         assessmentSectionToMerge
-                                     });
             var comparer = mocks.StrictMock<IAssessmentSectionMergeComparer>();
             comparer.Expect(c => c.Compare(originalAssessmentSection, assessmentSectionToMerge)).Return(true);
-            var mergeDataProvider = mocks.StrictMock<IAssessmentSectionMergeDataProvider>();
-            mergeDataProvider.Expect(mdp => mdp.GetMergeData(null)).IgnoreArguments().Return(
-                new AssessmentSectionMergeData(assessmentSectionToMerge, failureMechanismsToMerge));
+            var mergeDataProvider = mocks.StrictMock<IMergeDataProvider>();
+            mergeDataProvider.Expect(mdp => mdp.SelectData(null)).IgnoreArguments().Return(true);
+            mergeDataProvider.Expect(mdp => mdp.SelectedAssessmentSection).Return(assessmentSectionToMerge);
+            mergeDataProvider.Expect(mdp => mdp.SelectedFailureMechanisms).Return(failureMechanismsToMerge);
             var mergeHandler = mocks.StrictMock<IAssessmentSectionMergeHandler>();
             mergeHandler.Expect(mh => mh.PerformMerge(originalAssessmentSection, assessmentSectionToMerge, failureMechanismsToMerge)).Throw(new Exception());
             mocks.ReplayAll();
 
-            var merger = new AssessmentSectionMerger(filePathProvider, assessmentSectionProvider, comparer, mergeDataProvider, mergeHandler);
+            Action<string, AssessmentSectionsOwner> getAssessmentSectionsAction = (path, owner) =>
+            {
+                owner.AssessmentSections = new[]
+                {
+                    assessmentSectionToMerge
+                };
+            };
 
+            var merger = new AssessmentSectionMerger(filePathProvider, getAssessmentSectionsAction, comparer, mergeDataProvider, mergeHandler);
+
             // When
             Action call = () => merger.StartMerge(originalAssessmentSection);
 
@@ -376,15 +446,15 @@
             {
                 Assert.AreEqual(3, messages.Count());
 
-                Assert.AreEqual("Samenvoegen van trajectinformatie is gestart.", messages.ElementAt(0).Item1);
+                Assert.AreEqual($"Samenvoegen van traject {assessmentSectionToMerge.Name} met traject {originalAssessmentSection.Name} is gestart.", messages.ElementAt(0).Item1);
 
                 Tuple<string, Level, Exception> expectedLog = messages.ElementAt(1);
                 Assert.AreEqual("Er is een onverwachte fout opgetreden tijdens het samenvoegen van de trajecten.", expectedLog.Item1);
                 Assert.AreEqual(Level.Error, expectedLog.Item2);
                 Exception loggedException = expectedLog.Item3;
                 Assert.IsInstanceOf<Exception>(loggedException);
 
-                Assert.AreEqual("Samenvoegen van trajectinformatie is mislukt.", messages.ElementAt(2).Item1);
+                Assert.AreEqual("Samenvoegen van trajecten is mislukt.", messages.ElementAt(2).Item1);
             });
             mocks.VerifyAll();
         }
Index: Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj
===================================================================
diff -u -r5b7ef79633668d91363a37f5451dfaa25df60e07 -rd82ab38fadcd577385b43e5951c2f4ace3180275
--- Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj	(.../Ringtoets.Integration.Plugin.Test.csproj)	(revision 5b7ef79633668d91363a37f5451dfaa25df60e07)
+++ Ringtoets/Integration/test/Ringtoets.Integration.Plugin.Test/Ringtoets.Integration.Plugin.Test.csproj	(.../Ringtoets.Integration.Plugin.Test.csproj)	(revision d82ab38fadcd577385b43e5951c2f4ace3180275)
@@ -39,7 +39,7 @@
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="AssessmentSectionMergerTest.cs" />
+    <Compile Include="Merge\AssessmentSectionMergerTest.cs" />
     <Compile Include="ExportInfos\HydraulicBoundaryDatabaseContextExportInfoTest.cs" />
     <Compile Include="ExportInfos\ReferenceLineContextExportInfoTest.cs" />
     <Compile Include="FileImporters\ForeshoreProfileReplaceDataStrategyTest.cs" />