Add calculators cloning logic

StructureHelperTests/UnitTests/UpdateStrategiesTests/HasCalculatorsUpdateCloningStrategyTests.cs

@@ -0,0 +1,138 @@
+using Moq;
+using NUnit.Framework;
+using StructureHelperCommon.Infrastructures.Exceptions;
+using StructureHelperCommon.Infrastructures.Interfaces;
+using StructureHelperCommon.Models.Calculators;
+using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
+using StructureHelperLogics.NdmCalculations.Cracking;
+using System;
+using System.Collections.Generic;
+
+namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
+{
+
+
+    [TestFixture]
+    public class HasCalculatorsUpdateCloningStrategyTests
+    {
+        private Mock<ICloningStrategy> _cloningStrategyMock;
+        private Mock<IUpdateStrategy<IForceCalculator>> _forceCalculatorUpdateStrategyMock;
+        private Mock<IUpdateStrategy<ICrackCalculator>> _crackCalculatorUpdateStrategyMock;
+        private Mock<IUpdateStrategy<ILimitCurvesCalculator>> _limitCurvesCalculatorUpdateStrategyMock;
+        private HasCalculatorsUpdateCloningStrategy _strategy;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _cloningStrategyMock = new Mock<ICloningStrategy>();
+            _forceCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<IForceCalculator>>();
+            _crackCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<ICrackCalculator>>();
+            _limitCurvesCalculatorUpdateStrategyMock = new Mock<IUpdateStrategy<ILimitCurvesCalculator>>();
+
+            _strategy = new HasCalculatorsUpdateCloningStrategy(
+                _cloningStrategyMock.Object,
+                _forceCalculatorUpdateStrategyMock.Object,
+                _crackCalculatorUpdateStrategyMock.Object,
+                _limitCurvesCalculatorUpdateStrategyMock.Object
+            );
+        }
+
+        [Test]
+        public void Update_WithNullSourceObject_ThrowsException()
+        {
+            // Arrange
+            var targetObject = Mock.Of<IHasCalculators>();
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => _strategy.Update(targetObject, null));
+        }
+
+        [Test]
+        public void Update_WithNullTargetObject_ThrowsException()
+        {
+            // Arrange
+            var sourceObject = Mock.Of<IHasCalculators>();
+
+            // Act & Assert
+            Assert.Throws<StructureHelperException>(() => _strategy.Update(null, sourceObject));
+        }
+
+        [Test]
+        public void Update_WithSameSourceAndTarget_DoesNothing()
+        {
+            // Arrange
+            var calculators = new List<ICalculator> { Mock.Of<IForceCalculator>() };
+            var sourceObject = Mock.Of<IHasCalculators>(s => s.Calculators == calculators);
+            var targetObject = sourceObject;
+
+            // Act
+            _strategy.Update(targetObject, sourceObject);
+
+            // Assert
+            _cloningStrategyMock.VerifyNoOtherCalls();
+            _forceCalculatorUpdateStrategyMock.VerifyNoOtherCalls();
+            _crackCalculatorUpdateStrategyMock.VerifyNoOtherCalls();
+            _limitCurvesCalculatorUpdateStrategyMock.VerifyNoOtherCalls();
+        }
+
+        [Test]
+        public void Update_ProcessesEachCalculatorCorrectly()
+        {
+            // Arrange
+            var sourceForceCalculator = Mock.Of<IForceCalculator>(x => x.Name == "Force");
+            var sourceCrackCalculator = Mock.Of<ICrackCalculator>(x => x.Name == "Crack");
+            var sourceLimitCurvesCalculator = Mock.Of<ILimitCurvesCalculator>(x => x.Name == "Curves");
+            var sourceCalculators = new List<ICalculator>
+        {
+            sourceForceCalculator,
+            sourceCrackCalculator,
+            sourceLimitCurvesCalculator
+        };
+            var sourceObjectMock = new Mock<IHasCalculators>();
+            sourceObjectMock.Setup(s => s.Calculators).Returns(sourceCalculators);
+
+            var targetCalculators = new List<ICalculator>();
+            var targetObjectMock = new Mock<IHasCalculators>();
+            targetObjectMock.Setup(t => t.Calculators).Returns(targetCalculators);
+
+            var clonedForceCalculator = Mock.Of<IForceCalculator>();
+            var clonedCrackCalculator = Mock.Of<ICrackCalculator>();
+            var clonedLimitCurvesCalculator = Mock.Of<ILimitCurvesCalculator>();
+
+            _cloningStrategyMock.Setup(cs => cs.Clone(It.Is<ICalculator>(x => x.Name == "Force"), null)).Returns(clonedForceCalculator);
+            _cloningStrategyMock.Setup(cs => cs.Clone(It.Is<ICalculator>(x => x.Name == "Crack"), null)).Returns(clonedCrackCalculator);
+            _cloningStrategyMock.Setup(cs => cs.Clone(It.Is<ICalculator>(x => x.Name == "Curves"), null)).Returns(clonedLimitCurvesCalculator);
+
+            // Act
+            _strategy.Update(targetObjectMock.Object, sourceObjectMock.Object);
+
+            // Assert
+            Assert.That(targetCalculators, Has.Count.EqualTo(3));
+            Assert.That(targetCalculators, Contains.Item(clonedForceCalculator));
+            Assert.That(targetCalculators, Contains.Item(clonedCrackCalculator));
+            Assert.That(targetCalculators, Contains.Item(clonedLimitCurvesCalculator));
+
+            _forceCalculatorUpdateStrategyMock.Verify(f => f.Update(clonedForceCalculator, sourceForceCalculator), Times.Once);
+            _crackCalculatorUpdateStrategyMock.Verify(c => c.Update(clonedCrackCalculator, sourceCrackCalculator), Times.Once);
+            _limitCurvesCalculatorUpdateStrategyMock.Verify(l => l.Update(clonedLimitCurvesCalculator, sourceLimitCurvesCalculator), Times.Once);
+        }
+
+        [Test]
+        public void Update_WithUnknownCalculatorType_ThrowsException()
+        {
+            // Arrange
+            var unknownCalculator = Mock.Of<ICalculator>();
+            var sourceCalculators = new List<ICalculator> { unknownCalculator };
+            var sourceObjectMock = new Mock<IHasCalculators>();
+            sourceObjectMock.Setup(s => s.Calculators).Returns(sourceCalculators);
+
+            var targetObjectMock = new Mock<IHasCalculators>();
+            targetObjectMock.Setup(t => t.Calculators).Returns(new List<ICalculator>());
+
+            // Act & Assert
+            var exception = Assert.Throws<StructureHelperException>(() => _strategy.Update(targetObjectMock.Object, sourceObjectMock.Object));
+            Assert.That(exception.Message, Does.Contain(ErrorStrings.ObjectTypeIsUnknown));
+        }
+    }
+
+}