avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add Cross-section repositort tests

Browse Source
This commit is contained in:
Evgeny Redikultsev
2024-12-07 16:52:18 +05:00
parent 59b989ca89
commit ccaf9a927c
10 changed files with 588 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
StructureHelper/Windows/MainWindow/AnalysesManagerView.xaml
View File

@@ -185,7 +185,7 @@
<MenuItem Header="Edit" Command="{Binding EditCommand}" ToolTip="Create copy of analysis">
<MenuItem.Icon>
<Viewbox Height="16" Width="16">
<ContentControl ContentTemplate="{StaticResource CopyAnalysis}"/>
<ContentControl ContentTemplate="{StaticResource EditAnalysis}"/>
</Viewbox>
</MenuItem.Icon>
</MenuItem>

36
StructureHelperCommon/Infrastructures/Interfaces/HasForceActionUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,36 @@
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperCommon.Infrastructures.Interfaces
{
/// <summary>
/// Creates deep copy of internal elements of object which has calculators
/// </summary>
public class HasForceActionUpdateCloningStrategy : IUpdateStrategy<IHasForceActions>
{
private ICloningStrategy cloningStrategy;
public HasForceActionUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
public void Update(IHasForceActions targetObject, IHasForceActions sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.ForceActions.Clear();
foreach (var force in sourceObject.ForceActions)
{
var newForce = cloningStrategy.Clone(force);
targetObject.ForceActions.Add(newForce);
}
}
}
}

13
StructureHelperCommon/Infrastructures/Interfaces/IGetUpdateStrategy.cs Normal file
View File

@@ -0,0 +1,13 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperCommon.Infrastructures.Interfaces
{
public interface IGetUpdateStrategy<T> where T : ISaveable
{
IUpdateStrategy<T> GetStrategy();
}
}

133
StructureHelperLogics/Models/CrossSections/CrossSectionRepositoryCloneStrategy.cs
View File

@@ -3,10 +3,12 @@ using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Parameters;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.Models.Materials.Logics;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.Models.CrossSections
{
@@ -14,129 +16,48 @@ namespace StructureHelperLogics.Models.CrossSections
{
private ICloningStrategy cloningStrategy;
private CrossSectionRepository targetRepository;
private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasHeadMaterials> materialsUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
private IUpdateStrategy<IHasCalculators> calculatorsUpdateStrategy;
public CrossSectionRepositoryCloneStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasHeadMaterials> materialsUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy,
IUpdateStrategy<IHasCalculators> calculatorsUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.materialsUpdateStrategy = materialsUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
this.calculatorsUpdateStrategy = calculatorsUpdateStrategy;
}
public CrossSectionRepositoryCloneStrategy() : this (
new DeepCloningStrategy(),
new LimitCurvesCalculatorInputDataUpdateStrategy())
new HasForceActionUpdateCloningStrategy(null),
new HasMaterialsUpdateCloningStrategy(null),
new HasPrimitivesUpdateCloningStrategy(null),
new HasCalculatorsUpdateCloningStrategy(null))
{
forcesUpdateStrategy = new HasForceActionUpdateCloningStrategy(cloningStrategy);
materialsUpdateStrategy = new HasMaterialsUpdateCloningStrategy(cloningStrategy);
primitivesUpdateStrategy = new HasPrimitivesUpdateCloningStrategy(cloningStrategy);
calculatorsUpdateStrategy = new HasCalculatorsUpdateCloningStrategy(cloningStrategy);
}
public ICrossSectionRepository GetClone(ICrossSectionRepository sourceObject)
{
targetRepository = new();
ProcessForces(targetRepository, sourceObject);
ProcessMaterials(targetRepository, sourceObject);
ProcessPrimitives(targetRepository, sourceObject);
ProcessCalculators(targetRepository, sourceObject);
forcesUpdateStrategy.Update(targetRepository, sourceObject);
materialsUpdateStrategy.Update(targetRepository, sourceObject);
primitivesUpdateStrategy.Update(targetRepository, sourceObject);
calculatorsUpdateStrategy.Update(targetRepository, sourceObject);
return targetRepository;
}
private void ProcessCalculators(IHasCalculators targetObject, IHasCalculators sourceObject)
{
targetObject.Calculators.Clear();
foreach (var calculator in sourceObject.Calculators)
{
var newCalculator = cloningStrategy.Clone(calculator);
if (calculator is IForceCalculator forceCalculator)
{
ProcessForceCalculator(newCalculator, forceCalculator);
}
else if (calculator is CrackCalculator crackCalculator)
{
ProcessCrackCalculator(newCalculator, crackCalculator);
}
else if (calculator is ILimitCurvesCalculator limitCalculator)
{
ProcessLimitCurvesCalculator(newCalculator, limitCalculator);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));
}
targetRepository.Calculators.Add(newCalculator);
}
}
private void ProcessLimitCurvesCalculator(ICalculator newCalculator, ILimitCurvesCalculator limitCalculator)
{
var sourceData = limitCalculator.InputData;
var targetData = ((ILimitCurvesCalculator)newCalculator).InputData;
limitCurvesInputDataUpdateStrategy.Update(targetData, sourceData);
foreach (var series in targetData.PrimitiveSeries)
{
List<INdmPrimitive> collection = UpdatePrimitivesCollection(series);
series.Collection.AddRange(collection);
}
}
private void ProcessCrackCalculator(ICalculator newCalculator, CrackCalculator crackCalculator)
{
var sourceData = crackCalculator.InputData;
var targetData = ((ICrackCalculator)newCalculator).InputData;
ProcessPrimitives(targetData, sourceData);
ProcessForces(targetData, sourceData);
}
private void ProcessForceCalculator(ICalculator newCalculator, IForceCalculator forceCalculator)
{
var sourceData = forceCalculator.InputData;
var targetData = ((IForceCalculator)newCalculator).InputData;
ProcessPrimitives(targetData, sourceData);
ProcessForces(targetData, sourceData);
}
private List<INdmPrimitive> UpdatePrimitivesCollection(NamedCollection<INdmPrimitive> series)
{
List<INdmPrimitive> collection = new();
foreach (var item in series.Collection)
{
var newItem = cloningStrategy.Clone(item);
collection.Add(newItem);
}
series.Collection.Clear();
return collection;
}
private void ProcessMaterials(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject)
{
targetObject.HeadMaterials.Clear();
foreach (var material in sourceObject.HeadMaterials)
{
var newMaterial = cloningStrategy.Clone(material);
targetRepository.HeadMaterials.Add(newMaterial);
}
}
private void ProcessForces(IHasForceActions targetObject, IHasForceActions sourceObject)
{
targetObject.ForceActions.Clear();
foreach (var force in sourceObject.ForceActions)
{
var newForce = cloningStrategy.Clone(force);
targetObject.ForceActions.Add(newForce);
}
}
private void ProcessPrimitives(IHasPrimitives targetObject, IHasPrimitives sourceObject)
{
targetObject.Primitives.Clear();
foreach (var primitive in sourceObject.Primitives)
{
var newPrimitive = cloningStrategy.Clone(primitive);
var material = cloningStrategy.Clone(primitive.NdmElement.HeadMaterial);
newPrimitive.NdmElement.HeadMaterial = material;
targetObject.Primitives.Add(newPrimitive);
}
}
}
}

38
StructureHelperLogics/Models/Materials/Logics/HasMaterialsUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,38 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelperLogics.Models.Materials.Logics
{
/// <summary>
/// Creates deep copy of internal elements of object which has materials
/// </summary>
public class HasMaterialsUpdateCloningStrategy : IUpdateStrategy<IHasHeadMaterials>
{
private ICloningStrategy cloningStrategy;
public HasMaterialsUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
/// <inheritdoc/>
public void Update(IHasHeadMaterials targetObject, IHasHeadMaterials sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.HeadMaterials.Clear();
foreach (var material in sourceObject.HeadMaterials)
{
var newMaterial = cloningStrategy.Clone(material);
targetObject.HeadMaterials.Add(newMaterial);
}
}
}
}

114
StructureHelperLogics/NdmCalculations/Analyses/ByForces/Logics/HasCalculatorsUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,114 @@
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Calculators;
using StructureHelperCommon.Models.Parameters;
using StructureHelperCommon.Services;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces.LimitCurve;
using StructureHelperLogics.NdmCalculations.Cracking;
using StructureHelperLogics.NdmCalculations.Primitives;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
namespace StructureHelperLogics.NdmCalculations.Analyses.ByForces
{
/// <summary>
/// Creates deep copy of internal elements of object which has calculators
/// </summary>
public class HasCalculatorsUpdateCloningStrategy : IUpdateStrategy<IHasCalculators>
{
private ICloningStrategy cloningStrategy;
private IUpdateStrategy<IHasForceActions> forcesUpdateStrategy;
private IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy;
private IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy;
public HasCalculatorsUpdateCloningStrategy(ICloningStrategy cloningStrategy) : this(
cloningStrategy,
new HasForceActionUpdateCloningStrategy(cloningStrategy),
new HasPrimitivesUpdateCloningStrategy(cloningStrategy),
new LimitCurvesCalculatorInputDataUpdateStrategy()
)
{
}
public HasCalculatorsUpdateCloningStrategy(
ICloningStrategy cloningStrategy,
IUpdateStrategy<IHasForceActions> forcesUpdateStrategy,
IUpdateStrategy<IHasPrimitives> primitivesUpdateStrategy,
IUpdateStrategy<ILimitCurvesCalculatorInputData> limitCurvesInputDataUpdateStrategy)
{
this.cloningStrategy = cloningStrategy;
this.forcesUpdateStrategy = forcesUpdateStrategy;
this.primitivesUpdateStrategy = primitivesUpdateStrategy;
this.limitCurvesInputDataUpdateStrategy = limitCurvesInputDataUpdateStrategy;
}
public void Update(IHasCalculators targetObject, IHasCalculators sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Calculators.Clear();
foreach (var calculator in sourceObject.Calculators)
{
var newCalculator = cloningStrategy.Clone(calculator);
if (calculator is IForceCalculator forceCalculator)
{
ProcessForceCalculator(newCalculator, forceCalculator);
}
else if (calculator is CrackCalculator crackCalculator)
{
ProcessCrackCalculator(newCalculator, crackCalculator);
}
else if (calculator is ILimitCurvesCalculator limitCalculator)
{
ProcessLimitCurvesCalculator(newCalculator, limitCalculator);
}
else
{
throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknownObj(calculator));
}
targetObject.Calculators.Add(newCalculator);
}
}
private void ProcessLimitCurvesCalculator(ICalculator newCalculator, ILimitCurvesCalculator limitCalculator)
{
var sourceData = limitCalculator.InputData;
var targetData = ((ILimitCurvesCalculator)newCalculator).InputData;
limitCurvesInputDataUpdateStrategy.Update(targetData, sourceData);
foreach (var series in targetData.PrimitiveSeries)
{
List<INdmPrimitive> collection = UpdatePrimitivesCollection(series);
series.Collection.AddRange(collection);
}
}
private void ProcessCrackCalculator(ICalculator newCalculator, CrackCalculator crackCalculator)
{
var sourceData = crackCalculator.InputData;
var targetData = ((ICrackCalculator)newCalculator).InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
private void ProcessForceCalculator(ICalculator newCalculator, IForceCalculator forceCalculator)
{
var sourceData = forceCalculator.InputData;
var targetData = ((IForceCalculator)newCalculator).InputData;
primitivesUpdateStrategy.Update(targetData, sourceData);
forcesUpdateStrategy.Update(targetData, sourceData);
}
private List<INdmPrimitive> UpdatePrimitivesCollection(NamedCollection<INdmPrimitive> series)
{
List<INdmPrimitive> collection = new();
foreach (var item in series.Collection)
{
var newItem = cloningStrategy.Clone(item);
collection.Add(newItem);
}
series.Collection.Clear();
return collection;
}
}
}

50
StructureHelperLogics/NdmCalculations/Primitives/Logics/HasPrimitivesUpdateCloningStrategy.cs Normal file
View File

@@ -0,0 +1,50 @@
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Services;
namespace StructureHelperLogics.NdmCalculations.Primitives.Logics
{
/// <summary>
/// Creates deep copy of internal elements of object which has primitives
/// </summary>
public class HasPrimitivesUpdateCloningStrategy : IUpdateStrategy<IHasPrimitives>
{
private ICloningStrategy cloningStrategy;
public HasPrimitivesUpdateCloningStrategy(ICloningStrategy cloningStrategy)
{
this.cloningStrategy = cloningStrategy;
}
public void Update(IHasPrimitives targetObject, IHasPrimitives sourceObject)
{
CheckObject.IsNull(cloningStrategy);
CheckObject.IsNull(sourceObject);
CheckObject.IsNull(targetObject);
if (ReferenceEquals(targetObject, sourceObject)) { return; }
targetObject.Primitives.Clear();
foreach (var primitive in sourceObject.Primitives)
{
ProcessPrimitive(targetObject, primitive);
}
}
private void ProcessPrimitive(IHasPrimitives targetObject, INdmPrimitive primitive)
{
var newPrimitive = cloningStrategy.Clone(primitive);
if (primitive.NdmElement.HeadMaterial is not null)
{
var material = cloningStrategy.Clone(primitive.NdmElement.HeadMaterial);
newPrimitive.NdmElement.HeadMaterial = material;
}
targetObject.Primitives.Add(newPrimitive);
if (primitive is IHasHostPrimitive hasHost)
{
if (hasHost.HostPrimitive is not null)
{
INdmPrimitive hostPrimitive = cloningStrategy.Clone(hasHost.HostPrimitive);
(newPrimitive as IHasHostPrimitive).HostPrimitive = hostPrimitive;
}
}
}
}
}

95
StructureHelperTests/UnitTests/UpdateStrategiesTests/HasForceActionUpdateCloningStrategyTests.cs Normal file
View File

@@ -0,0 +1,95 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperCommon.Models.Forces;
using System.Collections.Generic;
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
{
[TestFixture]
public class HasForceActionUpdateCloningStrategyTests
{
private Mock<ICloningStrategy> _cloningStrategyMock;
private HasForceActionUpdateCloningStrategy _strategy;
[SetUp]
public void SetUp()
{
_cloningStrategyMock = new Mock<ICloningStrategy>();
_strategy = new HasForceActionUpdateCloningStrategy(_cloningStrategyMock.Object);
}
[Test]
public void Update_WithNullCloningStrategy_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasForceActions>();
var sourceObjectMock = new Mock<IHasForceActions>();
Assert.Throws<StructureHelperException>(() =>
{
new HasForceActionUpdateCloningStrategy(null).Update(targetObjectMock.Object, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithNullSourceObject_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasForceActions>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(targetObjectMock.Object, null);
});
}
[Test]
public void Update_WithNullTargetObject_ThrowsStructureHelperException()
{
var sourceObjectMock = new Mock<IHasForceActions>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(null, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithSameObjects_DoesNotPerformCloning()
{
var sourceObjectMock = new Mock<IHasForceActions>();
_strategy.Update(sourceObjectMock.Object, sourceObjectMock.Object);
_cloningStrategyMock.Verify(cs => cs.Clone(It.IsAny<object>(), null), Times.Never);
}
[Test]
public void Update_ClonesEachForceActionAndAddsToTargetObject()
{
// Arrange
var targetForceActions = new List<IForceAction>();
var targetObjectMock = new Mock<IHasForceActions>();
var sourceObjectMock = new Mock<IHasForceActions>();
var sourceForceActions = new List<IForceAction> { new ForceCombinationByFactor(), new ForceCombinationByFactor() };
var clonedForceActions = new List<IForceAction> { new ForceCombinationByFactor(), new ForceCombinationByFactor() };
sourceObjectMock.SetupGet(s => s.ForceActions).Returns(sourceForceActions);
targetObjectMock.SetupGet(t => t.ForceActions).Returns(targetForceActions);
_cloningStrategyMock.Setup(cs => cs.Clone(sourceForceActions[0], null))
.Returns(clonedForceActions[0]);
_cloningStrategyMock.Setup(cs => cs.Clone(sourceForceActions[1], null))
.Returns(clonedForceActions[1]);
// Act
_strategy.Update(targetObjectMock.Object, sourceObjectMock.Object);
// Assert
Assert.That(targetForceActions, Has.Count.EqualTo(2));
Assert.That(targetForceActions, Is.EquivalentTo(clonedForceActions));
_cloningStrategyMock.Verify(cs => cs.Clone(sourceForceActions[0], null), Times.Once);
_cloningStrategyMock.Verify(cs => cs.Clone(sourceForceActions[1], null), Times.Once);
}
}
}

103
StructureHelperTests/UnitTests/UpdateStrategiesTests/HasMaterialsUpdateCloningStrategyTests.cs Normal file
View File

@@ -0,0 +1,103 @@
using Moq;
using NUnit.Framework;
using StructureHelper.Models.Materials;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.Models.Materials.Logics;
using StructureHelperLogics.Models.Materials;
using System.Collections.Generic;
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
{
[TestFixture]
public class HasMaterialsUpdateCloningStrategyTests
{
private Mock<ICloningStrategy> _cloningStrategyMock;
private HasMaterialsUpdateCloningStrategy _strategy;
[SetUp]
public void SetUp()
{
_cloningStrategyMock = new Mock<ICloningStrategy>();
_strategy = new HasMaterialsUpdateCloningStrategy(_cloningStrategyMock.Object);
}
[Test]
public void Update_WithNullCloningStrategy_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasHeadMaterials>();
var sourceObjectMock = new Mock<IHasHeadMaterials>();
Assert.Throws<StructureHelperException>(() =>
{
new HasMaterialsUpdateCloningStrategy(null).Update(targetObjectMock.Object, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithNullSourceObject_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasHeadMaterials>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(targetObjectMock.Object, null);
});
}
[Test]
public void Update_WithNullTargetObject_ThrowsStructureHelperException()
{
var sourceObjectMock = new Mock<IHasHeadMaterials>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(null, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithSameObjects_DoesNotPerformCloning()
{
var sourceObjectMock = new Mock<IHasHeadMaterials>();
_strategy.Update(sourceObjectMock.Object, sourceObjectMock.Object);
_cloningStrategyMock.Verify(cs => cs.Clone(It.IsAny<IHeadMaterial>(), null), Times.Never);
}
[Test]
public void Update_ClonesAndAddsEachMaterialToTarget()
{
// Arrange
var targetMaterials = new List<IHeadMaterial>();
var targetObjectMock = new Mock<IHasHeadMaterials>();
targetObjectMock.SetupGet(t => t.HeadMaterials).Returns(targetMaterials);
var sourceMaterials = new List<IHeadMaterial>
{
Mock.Of<IHeadMaterial>(m => m.Name == "Material1"),
Mock.Of<IHeadMaterial>(m => m.Name == "Material2")
};
var sourceObjectMock = new Mock<IHasHeadMaterials>();
sourceObjectMock.SetupGet(s => s.HeadMaterials).Returns(sourceMaterials);
var clonedMaterial1 = Mock.Of<IHeadMaterial>(m => m.Name == "ClonedMaterial1");
var clonedMaterial2 = Mock.Of<IHeadMaterial>(m => m.Name == "ClonedMaterial2");
_cloningStrategyMock.Setup(cs => cs.Clone(sourceMaterials[0], null)).Returns(clonedMaterial1);
_cloningStrategyMock.Setup(cs => cs.Clone(sourceMaterials[1], null)).Returns(clonedMaterial2);
// Act
_strategy.Update(targetObjectMock.Object, sourceObjectMock.Object);
// Assert
//Assert.IsEmpty(targetMaterials, "Target materials should be cleared before adding new ones.");
Assert.That(targetMaterials, Has.Count.EqualTo(2));
Assert.That(targetMaterials, Contains.Item(clonedMaterial1));
Assert.That(targetMaterials, Contains.Item(clonedMaterial2));
_cloningStrategyMock.Verify(cs => cs.Clone(sourceMaterials[0], null), Times.Once);
_cloningStrategyMock.Verify(cs => cs.Clone(sourceMaterials[1], null), Times.Once);
}
}
}

111
StructureHelperTests/UnitTests/UpdateStrategiesTests/HasPrimitivesUpdateCloningStrategyTests.cs Normal file
View File

@@ -0,0 +1,111 @@
using Moq;
using NUnit.Framework;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Interfaces;
using StructureHelperLogics.NdmCalculations.Primitives.Logics;
using StructureHelperLogics.NdmCalculations.Primitives;
using System.Collections.Generic;
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
{
[TestFixture]
public class HasPrimitivesUpdateCloningStrategyTests
{
private Mock<ICloningStrategy> _cloningStrategyMock;
private HasPrimitivesUpdateCloningStrategy _strategy;
[SetUp]
public void SetUp()
{
_cloningStrategyMock = new Mock<ICloningStrategy>();
_strategy = new HasPrimitivesUpdateCloningStrategy(_cloningStrategyMock.Object);
}
[Test]
public void Update_WithNullCloningStrategy_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasPrimitives>();
var sourceObjectMock = new Mock<IHasPrimitives>();
Assert.Throws<StructureHelperException>(() =>
{
new HasPrimitivesUpdateCloningStrategy(null).Update(targetObjectMock.Object, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithNullSourceObject_ThrowsStructureHelperException()
{
var targetObjectMock = new Mock<IHasPrimitives>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(targetObjectMock.Object, null);
});
}
[Test]
public void Update_WithNullTargetObject_ThrowsStructureHelperException()
{
var sourceObjectMock = new Mock<IHasPrimitives>();
Assert.Throws<StructureHelperException>(() =>
{
_strategy.Update(null, sourceObjectMock.Object);
});
}
[Test]
public void Update_WithSameObjects_DoesNotPerformCloning()
{
var sourceObjectMock = new Mock<IHasPrimitives>();
_strategy.Update(sourceObjectMock.Object, sourceObjectMock.Object);
_cloningStrategyMock.Verify(cs => cs.Clone(It.IsAny<INdmPrimitive>(), null), Times.Never);
}
[Test]
public void Update_ProcessesEachPrimitiveCorrectly()
{
// Arrange
ICloningStrategy deepCloningStrategy = new DeepCloningStrategy();
var targetPrimitives = new List<INdmPrimitive>();
var targetObjectMock = new Mock<IHasPrimitives>();
targetObjectMock.SetupGet(t => t.Primitives).Returns(targetPrimitives);
var sourcePrimitive1 = Mock.Of<INdmPrimitive>(p => p.Name == "sp1" && p.NdmElement == new NdmElement());
var sourceHostPrimitive = Mock.Of<INdmPrimitive>(p => p.Name == "shp" && p.NdmElement == new NdmElement());
var sourcePrimitive2 = Mock.Of<IRebarNdmPrimitive>(p => p.Name == "sp2" && p.NdmElement == new NdmElement() && p.HostPrimitive == sourceHostPrimitive);
var sourcePrimitives = new List<INdmPrimitive>
{
sourcePrimitive1,
sourcePrimitive2
};
var sourceObjectMock = new Mock<IHasPrimitives>();
sourceObjectMock.SetupGet(s => s.Primitives).Returns(sourcePrimitives);
var clonedPrimitive1 = Mock.Of<INdmPrimitive>(p => p.Name == "cp1" && p.NdmElement == new NdmElement());
var clonedPrimitive2 = Mock.Of<IRebarNdmPrimitive>(p => p.Name == "cp2" && p.NdmElement == new NdmElement() && p.HostPrimitive == sourceHostPrimitive);
var clonedHostPrimitive = Mock.Of<INdmPrimitive>(p => p.Name == "chp" && p.NdmElement == new NdmElement());
_cloningStrategyMock.Setup(cs => cs.Clone(sourcePrimitive1, null)).Returns(clonedPrimitive1);
_cloningStrategyMock.Setup(cs => cs.Clone(It.Is<INdmPrimitive>(p => p.Name == "sp2"), null)).Returns(clonedPrimitive2);
//_cloningStrategyMock.Setup(cs => cs.Clone(sourcePrimitive2, null)).Returns(clonedPrimitive2);
_cloningStrategyMock.Setup(cs => cs.Clone(sourcePrimitive2.HostPrimitive, null)).Returns(clonedHostPrimitive);
// Act
_strategy.Update(targetObjectMock.Object, sourceObjectMock.Object);
// Assert
//Assert.IsEmpty(targetPrimitives, "Target primitives should be cleared before adding new ones.");
Assert.That(targetPrimitives, Has.Count.EqualTo(2));
Assert.That(targetPrimitives, Contains.Item(clonedPrimitive1));
Assert.That(targetPrimitives, Contains.Item(clonedPrimitive2));
_cloningStrategyMock.Verify(cs => cs.Clone(sourcePrimitive1, null), Times.Once);
_cloningStrategyMock.Verify(cs => cs.Clone(It.Is<INdmPrimitive>(p => p.Name == "sp2"), null), Times.Once);
//_cloningStrategyMock.Verify(cs => cs.Clone(sourcePrimitive2, null), Times.Once);
_cloningStrategyMock.Verify(cs => cs.Clone(sourcePrimitive2.HostPrimitive, null), Times.Once);
}
}
}