Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -r34635692bc7437564e0f99ae64cc49a7208d7fad -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.cs (.../GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.cs) (revision 34635692bc7437564e0f99ae64cc49a7208d7fad) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.cs (.../GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -167,5 +168,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (GrassCoverSlipOffInwardsFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -r85312e2d99d2624f57cbd1ce49c2a3122b00e5cf -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.cs (.../GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.cs) (revision 85312e2d99d2624f57cbd1ce49c2a3122b00e5cf) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.cs (.../GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -167,5 +168,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (GrassCoverSlipOffOutwardsFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -rd004dced1e431cea58063125752ebe253ba66066 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactory.cs (.../MicrostabilityFailureMechanismSectionResultAssemblyFactory.cs) (revision d004dced1e431cea58063125752ebe253ba66066) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactory.cs (.../MicrostabilityFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -167,5 +168,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (MicrostabilityFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -r5cf7d7a7f3a61834a5e59f4b7a9eacb278e710c9 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactory.cs (.../PipingStructureFailureMechanismSectionResultAssemblyFactory.cs) (revision 5cf7d7a7f3a61834a5e59f4b7a9eacb278e710c9) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactory.cs (.../PipingStructureFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -167,5 +168,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (PipingStructureFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -ree906b38aaaf4333436ac5e4bc4eebcc9102afa1 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.cs) (revision ee906b38aaaf4333436ac5e4bc4eebcc9102afa1) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -133,5 +134,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -r9c9e8e92717a1b2d1fb657196c7adaf18ff7589d -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.cs (.../TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.cs) (revision 9c9e8e92717a1b2d1fb657196c7adaf18ff7589d) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.cs (.../TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -133,5 +134,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (TechnicalInnovationFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.cs =================================================================== diff -u -reb8fcc9412c88632850aa72122d89f33b603ed04 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.cs (.../WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.cs) (revision eb8fcc9412c88632850aa72122d89f33b603ed04) +++ Ringtoets/Integration/src/Ringtoets.Integration.Data/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.cs (.../WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Collections.Generic; using Ringtoets.AssemblyTool.Data; using Ringtoets.AssemblyTool.KernelWrapper.Calculators; using Ringtoets.AssemblyTool.KernelWrapper.Calculators.Assembly; @@ -133,5 +134,56 @@ throw new AssemblyException(e.Message, e); } } + + /// + /// Assembles the failure mechanism assembly. + /// + /// The failure mechanism section results to + /// get the assembly for. + /// Indicator whether the manual assembly should be used in the assembly. + /// A . + /// Thrown when + /// is null. + /// Thrown when the + /// could not be created. + public static FailureMechanismAssemblyCategoryGroup AssembleFailureMechanism( + IEnumerable failureMechanismSectionResults, + bool considerManualAssembly = true) + { + if (failureMechanismSectionResults == null) + { + throw new ArgumentNullException(nameof(failureMechanismSectionResults)); + } + + IAssemblyToolCalculatorFactory calculatorFactory = AssemblyToolCalculatorFactory.Instance; + IFailureMechanismSectionAssemblyCalculator sectionCalculator = + calculatorFactory.CreateFailureMechanismSectionAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + var sectionAssemblies = new List(); + + try + { + foreach (WaterPressureAsphaltCoverFailureMechanismSectionResult sectionResult in failureMechanismSectionResults) + { + if (sectionResult.UseManualAssemblyCategoryGroup && considerManualAssembly) + { + sectionAssemblies.Add(sectionCalculator.AssembleTailorMadeAssessment(sectionResult.ManualAssemblyCategoryGroup)); + } + else + { + sectionAssemblies.Add(AssembleCombinedAssessment(sectionResult)); + } + } + + IFailureMechanismAssemblyCalculator calculator = + calculatorFactory.CreateFailureMechanismAssemblyCalculator(AssemblyToolKernelFactory.Instance); + + return calculator.AssembleFailureMechanism(sectionAssemblies); + } + catch (Exception e) when (e is FailureMechanismAssemblyCalculatorException || e is FailureMechanismSectionAssemblyCalculatorException) + { + throw new AssemblyException(e.Message, e); + } + } } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r7b6a4a6e7b2536e45a764777a4c9bb1b419ccb26 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 7b6a4a6e7b2536e45a764777a4c9bb1b419ccb26) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -366,5 +367,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => GrassCoverSlipOffInwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new GrassCoverSlipOffInwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -rae9999ca55b34f4d126084a09cd08210cbdca70e -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision ae9999ca55b34f4d126084a09cd08210cbdca70e) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs (.../GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -365,5 +366,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => GrassCoverSlipOffOutwardsFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new GrassCoverSlipOffOutwardsFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r79963a430cd55ba81f06f13b20693f06d47ef150 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactoryTest.cs (.../MicrostabilityFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 79963a430cd55ba81f06f13b20693f06d47ef150) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/MicrostabilityFailureMechanismSectionResultAssemblyFactoryTest.cs (.../MicrostabilityFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -366,5 +367,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => MicrostabilityFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new MicrostabilityFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r5cf7d7a7f3a61834a5e59f4b7a9eacb278e710c9 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactoryTest.cs (.../PipingStructureFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 5cf7d7a7f3a61834a5e59f4b7a9eacb278e710c9) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/PipingStructureFailureMechanismSectionResultAssemblyFactoryTest.cs (.../PipingStructureFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -366,5 +367,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => PipingStructureFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new PipingStructureFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -ree906b38aaaf4333436ac5e4bc4eebcc9102afa1 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactoryTest.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision ee906b38aaaf4333436ac5e4bc4eebcc9102afa1) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactoryTest.cs (.../StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -286,5 +287,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => StrengthStabilityLengthwiseConstructionFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new StrengthStabilityLengthwiseConstructionFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r9c9e8e92717a1b2d1fb657196c7adaf18ff7589d -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactoryTest.cs (.../TechnicalInnovationFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 9c9e8e92717a1b2d1fb657196c7adaf18ff7589d) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/TechnicalInnovationFailureMechanismSectionResultAssemblyFactoryTest.cs (.../TechnicalInnovationFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -285,5 +286,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => TechnicalInnovationFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new TechnicalInnovationFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file Index: Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactoryTest.cs =================================================================== diff -u -r1642221ff1992d67c9c11756e64056d2d77b0068 -r2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe --- Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactoryTest.cs (.../WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 1642221ff1992d67c9c11756e64056d2d77b0068) +++ Ringtoets/Integration/test/Ringtoets.Integration.Data.Test/StandAlone/AssemblyFactories/WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactoryTest.cs (.../WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactoryTest.cs) (revision 2d22ea5a1a86139d67e2e2c0a5e5b8ea55614efe) @@ -20,6 +20,7 @@ // All rights reserved. using System; +using System.Linq; using Core.Common.TestUtil; using NUnit.Framework; using Ringtoets.AssemblyTool.Data; @@ -285,5 +286,166 @@ } #endregion + + #region Failure Mechanism Assembly + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionResultsNull_ThrowsArgumentNullException() + { + // Call + TestDelegate call = () => WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(null); + + // Assert + var exception = Assert.Throws(call); + Assert.AreEqual("failureMechanismSectionResults", exception.ParamName); + } + + [Test] + public void AssembleFailureMechanism_WithoutManualInput_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyTrue_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleTailorMadeAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_WithManualInputConsiderManualAssemblyFalse_SetsInputOnCalculator() + { + // Setup + var sectionResults = new[] + { + new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + { + UseManualAssemblyCategoryGroup = true, + ManualAssemblyCategoryGroup = new Random(39).NextEnumValue() + } + }; + + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism(sectionResults, false); + + // Assert + FailureMechanismSectionAssemblyCategoryGroup assemblyCategory = + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleCombinedAssessment(sectionResults.Single()); + Assert.AreEqual(assemblyCategory, calculator.FailureMechanismSectionCategories.Single()); + } + } + + [Test] + public void AssembleFailureMechanism_AssemblyRan_ReturnsOutput() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorFactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator; + + // Call + FailureMechanismAssemblyCategoryGroup actualOutput = + WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + Assert.AreEqual(calculator.FailureMechanismAssemblyCategoryGroupOutput, actualOutput); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismAssemblyCalculator; + calculator.ThrowExceptionOnCalculate = true; + + // Call + TestDelegate call = () => WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + Enumerable.Empty()); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + [Test] + public void AssembleFailureMechanism_FailureMechanismSectionCalculatorThrowsException_ThrowsAssemblyException() + { + // Setup + using (new AssemblyToolCalculatorFactoryConfig()) + { + var calculatorfactory = (TestAssemblyToolCalculatorFactory) AssemblyToolCalculatorFactory.Instance; + FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorfactory.LastCreatedFailureMechanismSectionAssemblyCalculator; + calculator.ThrowExceptionOnCalculateCombinedAssembly = true; + + // Call + TestDelegate call = () => WaterPressureAsphaltCoverFailureMechanismSectionResultAssemblyFactory.AssembleFailureMechanism( + new[] + { + new WaterPressureAsphaltCoverFailureMechanismSectionResult(FailureMechanismSectionTestFactory.CreateFailureMechanismSection()) + }); + + // Assert + var exception = Assert.Throws(call); + Exception innerException = exception.InnerException; + Assert.IsInstanceOf(innerException); + Assert.AreEqual(innerException.Message, exception.Message); + } + } + + #endregion } } \ No newline at end of file