Analisys manager window was added
This commit is contained in:
RedikultsevEvg
@@ -10,98 +10,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks
|
||||
[TestFixture]
|
||||
public class CrackWidthCalculationLogicTests
|
||||
{
|
||||
private Mock<IRebarStressCalculator> _calculator;
|
||||
private Mock<ICrackWidthLogic> _mockCrackWidthLogic;
|
||||
private Mock<IShiftTraceLogger> _mockTraceLogger;
|
||||
private CrackWidthCalculationLogic _logic;
|
||||
private IRebarCrackCalculatorInputData _inputData;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_calculator = new Mock<IRebarStressCalculator>();
|
||||
_mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
|
||||
_mockTraceLogger = new Mock<IShiftTraceLogger>();
|
||||
_inputData = new RebarCrackCalculatorInputData
|
||||
{
|
||||
|
||||
};
|
||||
|
||||
_inputData.UserCrackInputData = new UserCrackInputData();
|
||||
|
||||
_logic = new CrackWidthCalculationLogic(_calculator.Object, _mockCrackWidthLogic.Object, _mockTraceLogger.Object)
|
||||
{
|
||||
InputData = _inputData
|
||||
};
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Run_ShouldPrepareNewResultAndProcessCalculations()
|
||||
{
|
||||
// Arrange
|
||||
_mockCrackWidthLogic.Setup(m => m.GetCrackWidth())
|
||||
.Returns(0.5); // Mock the GetCrackWidth method
|
||||
|
||||
// Act
|
||||
_logic.Run();
|
||||
|
||||
// Assert
|
||||
Assert.NotNull(_logic.Result);
|
||||
Assert.IsTrue(_logic.Result.IsValid);
|
||||
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ProcessLongTermCalculation_ShouldReturnExpectedResult()
|
||||
{
|
||||
// Arrange
|
||||
_mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
|
||||
.Returns(0.5) // longTermLoadLongTermConcreteCrackWidth
|
||||
.Returns(0.2); // longTermLoadShortConcreteWidth
|
||||
|
||||
// Act
|
||||
var result = _logic.ProcessLongTermCalculations();
|
||||
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(0.5, result.CrackWidth);
|
||||
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ProcessShortTermCalculations_ShouldReturnExpectedResult()
|
||||
{
|
||||
// Arrange
|
||||
_mockCrackWidthLogic.SetupSequence(m => m.GetCrackWidth())
|
||||
.Returns(0.2) // longTermLoadShortConcreteWidth
|
||||
.Returns(0.3); // fullLoadShortConcreteCrackWidth
|
||||
|
||||
// Act
|
||||
var result = _logic.ProcessShortTermCalculations();
|
||||
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.AreEqual(0.0, result.CrackWidth); // Assuming acrcShort would be 0 in this scenario
|
||||
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>()), Times.AtLeastOnce);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetRebarStressResult_ShouldReturnValidResult()
|
||||
{
|
||||
// Arrange
|
||||
var mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
|
||||
var expectedResult = new RebarStressResult { IsValid = true };
|
||||
mockRebarStressCalculator.Setup(c => c.Run());
|
||||
mockRebarStressCalculator.Setup(c => c.Result).Returns(expectedResult);
|
||||
|
||||
// Act
|
||||
var result = _logic.GetRebarStressResult(_inputData.ShortRebarData);
|
||||
|
||||
// Assert
|
||||
Assert.NotNull(result);
|
||||
Assert.IsTrue(result.IsValid);
|
||||
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Never);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@@ -4,6 +4,10 @@ using StructureHelperCommon.Models;
|
||||
using StructureHelperLogics.NdmCalculations.Cracking;
|
||||
using StructureHelperLogics.NdmCalculations.Primitives;
|
||||
using StructureHelperCommon.Models.Forces;
|
||||
using StructureHelperCommon.Models.Calculators;
|
||||
using Autofac.Features.ResolveAnything;
|
||||
using StructureHelperLogics.NdmCalculations.Triangulations;
|
||||
using LoaderCalculator.Data.Ndms;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
|
||||
{
|
||||
@@ -11,89 +15,7 @@ namespace StructureHelperTests.UnitTests.Ndms.Cracks.InputDataTests
|
||||
[TestFixture]
|
||||
public class CrackWidthCalculationLogicTests
|
||||
{
|
||||
private Mock<IRebarStressCalculator> _calculator;
|
||||
private Mock<ICrackWidthLogic> mockCrackWidthLogic;
|
||||
private Mock<IShiftTraceLogger> mockTraceLogger;
|
||||
private Mock<IRebarCrackCalculatorInputData> mockInputData;
|
||||
private Mock<IUserCrackInputData> mockUserCrackInputData;
|
||||
private Mock<IRebarPrimitive> mockRebarPrimitive;
|
||||
private Mock<IRebarStressCalculator> mockRebarStressCalculator;
|
||||
private CrackWidthCalculationLogic crackWidthCalculationLogic;
|
||||
private Mock<IRebarCrackInputData> mockRebarCrackInputData;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_calculator = new Mock<IRebarStressCalculator>();
|
||||
mockCrackWidthLogic = new Mock<ICrackWidthLogic>();
|
||||
mockTraceLogger = new Mock<IShiftTraceLogger>();
|
||||
mockInputData = new Mock<IRebarCrackCalculatorInputData>();
|
||||
mockUserCrackInputData = new Mock<IUserCrackInputData>();
|
||||
mockRebarPrimitive = new Mock<IRebarPrimitive>();
|
||||
mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
|
||||
mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
|
||||
|
||||
mockInputData.Setup(x => x.UserCrackInputData).Returns(mockUserCrackInputData.Object);
|
||||
mockInputData.Setup(x => x.LongRebarData).Returns(mockRebarCrackInputData.Object);
|
||||
mockInputData.Setup(x => x.ShortRebarData).Returns(mockRebarCrackInputData.Object);
|
||||
mockInputData.Setup(x => x.RebarPrimitive).Returns(mockRebarPrimitive.Object);
|
||||
|
||||
mockRebarCrackInputData.Setup(x => x.ForceTuple).Returns(new ForceTuple());
|
||||
|
||||
crackWidthCalculationLogic = new CrackWidthCalculationLogic(_calculator.Object, mockCrackWidthLogic.Object, mockTraceLogger.Object)
|
||||
{
|
||||
InputData = mockInputData.Object
|
||||
};
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Run_ShouldPrepareNewResultAndProcessCalculations()
|
||||
{
|
||||
// Arrange
|
||||
mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.5);
|
||||
|
||||
// Act
|
||||
crackWidthCalculationLogic.Run();
|
||||
|
||||
// Assert
|
||||
mockCrackWidthLogic.Verify(x => x.GetCrackWidth(), Times.AtLeastOnce);
|
||||
Assert.IsNotNull(crackWidthCalculationLogic.Result);
|
||||
Assert.IsTrue(crackWidthCalculationLogic.Result.IsValid);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ProcessShortTermCalculations_ShouldCalculateCorrectShortTermCrackWidth()
|
||||
{
|
||||
// Arrange
|
||||
mockUserCrackInputData.Setup(x => x.UltimateShortCrackWidth).Returns(1.0);
|
||||
mockCrackWidthLogic.SetupSequence(x => x.GetCrackWidth())
|
||||
.Returns(0.6) // longTermLoadShortConcreteWidth
|
||||
.Returns(0.8); // fullLoadShortConcreteCrackWidth
|
||||
|
||||
crackWidthCalculationLogic.InputData = mockInputData.Object;
|
||||
|
||||
// Act
|
||||
var shortTermResult = crackWidthCalculationLogic.ProcessShortTermCalculations();
|
||||
|
||||
// Assert
|
||||
Assert.AreEqual(1.2, shortTermResult.CrackWidth);
|
||||
Assert.AreEqual(1.0, shortTermResult.UltimateCrackWidth);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void ProcessLongTermCalculations_ShouldCalculateCorrectLongTermCrackWidth()
|
||||
{
|
||||
// Arrange
|
||||
mockUserCrackInputData.Setup(x => x.UltimateLongCrackWidth).Returns(1.2);
|
||||
mockCrackWidthLogic.Setup(x => x.GetCrackWidth()).Returns(0.9);
|
||||
|
||||
// Act
|
||||
var longTermResult = crackWidthCalculationLogic.ProcessLongTermCalculations();
|
||||
|
||||
// Assert
|
||||
Assert.AreEqual(0.9, longTermResult.CrackWidth);
|
||||
Assert.AreEqual(1.2, longTermResult.UltimateCrackWidth);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,80 @@
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using StructureHelperCommon.Infrastructures.Exceptions;
|
||||
using StructureHelperCommon.Models.Loggers;
|
||||
using StructureHelperCommon.Models;
|
||||
using StructureHelperLogics.NdmCalculations.Cracking;
|
||||
using StructureHelperLogics.NdmCalculations.Primitives;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.Ndms.Cracks
|
||||
{
|
||||
|
||||
|
||||
[TestFixture]
|
||||
public class RebarStressResultLogicTests
|
||||
{
|
||||
private Mock<IRebarStressCalculator> _mockRebarStressCalculator;
|
||||
private Mock<IShiftTraceLogger> _mockTraceLogger;
|
||||
private RebarStressResultLogic _rebarStressResultLogic;
|
||||
|
||||
[SetUp]
|
||||
public void Setup()
|
||||
{
|
||||
_mockRebarStressCalculator = new Mock<IRebarStressCalculator>();
|
||||
_mockTraceLogger = new Mock<IShiftTraceLogger>();
|
||||
_rebarStressResultLogic = new RebarStressResultLogic(_mockRebarStressCalculator.Object, _mockTraceLogger.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetRebarStressResult_WhenCalculationIsValid_ReturnsRebarStressResult()
|
||||
{
|
||||
// Arrange
|
||||
var mockRebarStressResult = new RebarStressResult
|
||||
{
|
||||
IsValid = true
|
||||
};
|
||||
|
||||
_mockRebarStressCalculator.Setup(x => x.Run());
|
||||
_mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
|
||||
|
||||
var mockRebarPrimitive = new Mock<IRebarPrimitive>();
|
||||
var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
|
||||
|
||||
_rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
|
||||
_rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
|
||||
|
||||
// Act
|
||||
var result = _rebarStressResultLogic.GetRebarStressResult();
|
||||
|
||||
// Assert
|
||||
Assert.AreEqual(mockRebarStressResult, result);
|
||||
_mockRebarStressCalculator.Verify(x => x.Run(), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void GetRebarStressResult_WhenCalculationIsInvalid_ThrowsStructureHelperException()
|
||||
{
|
||||
// Arrange
|
||||
var mockRebarStressResult = new RebarStressResult
|
||||
{
|
||||
IsValid = false,
|
||||
Description = "Error in calculation"
|
||||
};
|
||||
|
||||
_mockRebarStressCalculator.Setup(x => x.Run());
|
||||
_mockRebarStressCalculator.Setup(x => x.Result).Returns(mockRebarStressResult);
|
||||
|
||||
var mockRebarPrimitive = new Mock<IRebarPrimitive>();
|
||||
var mockRebarCrackInputData = new Mock<IRebarCrackInputData>();
|
||||
|
||||
_rebarStressResultLogic.RebarPrimitive = mockRebarPrimitive.Object;
|
||||
_rebarStressResultLogic.RebarCrackInputData = mockRebarCrackInputData.Object;
|
||||
|
||||
// Act & Assert
|
||||
var ex = Assert.Throws<StructureHelperException>(() => _rebarStressResultLogic.GetRebarStressResult());
|
||||
Assert.That(ex.Message, Is.EqualTo(LoggerStrings.CalculationError + mockRebarStressResult.Description));
|
||||
_mockTraceLogger.Verify(x => x.AddMessage(It.IsAny<string>(), TraceLogStatuses.Error), Times.Once);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,77 @@
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using StructureHelperCommon.Infrastructures.Exceptions;
|
||||
using StructureHelperCommon.Infrastructures.Interfaces;
|
||||
using StructureHelperLogics.Models.Materials;
|
||||
using System;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
|
||||
{
|
||||
|
||||
|
||||
namespace YourNamespace.Tests
|
||||
{
|
||||
[TestFixture]
|
||||
public class ConcreteLibUpdateStrategyTests
|
||||
{
|
||||
private Mock<IUpdateStrategy<ILibMaterial>> mockLibUpdateStrategy;
|
||||
private ConcreteLibUpdateStrategy strategy;
|
||||
|
||||
[SetUp]
|
||||
public void Setup()
|
||||
{
|
||||
mockLibUpdateStrategy = new Mock<IUpdateStrategy<ILibMaterial>>();
|
||||
strategy = new ConcreteLibUpdateStrategy(mockLibUpdateStrategy.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldUpdateTargetObject_WhenSourceAndTargetAreNotTheSame()
|
||||
{
|
||||
// Arrange
|
||||
var targetMock = new Mock<IConcreteLibMaterial>();
|
||||
var sourceMock = new Mock<IConcreteLibMaterial>();
|
||||
|
||||
sourceMock.Setup(s => s.TensionForULS).Returns(false);
|
||||
sourceMock.Setup(s => s.TensionForSLS).Returns(true);
|
||||
sourceMock.Setup(s => s.RelativeHumidity).Returns(0.75);
|
||||
|
||||
// Act
|
||||
strategy.Update(targetMock.Object, sourceMock.Object);
|
||||
|
||||
// Assert
|
||||
mockLibUpdateStrategy.Verify(l => l.Update(targetMock.Object, sourceMock.Object), Times.Once);
|
||||
targetMock.VerifySet(t => t.TensionForULS = false);
|
||||
targetMock.VerifySet(t => t.TensionForSLS = true);
|
||||
targetMock.VerifySet(t => t.RelativeHumidity = 0.75);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldNotUpdate_WhenSourceAndTargetAreSame()
|
||||
{
|
||||
// Arrange
|
||||
var targetMock = new Mock<IConcreteLibMaterial>();
|
||||
|
||||
// Act
|
||||
strategy.Update(targetMock.Object, targetMock.Object);
|
||||
|
||||
// Assert
|
||||
mockLibUpdateStrategy.Verify(l => l.Update(It.IsAny<IConcreteLibMaterial>(), It.IsAny<IConcreteLibMaterial>()), Times.Never);
|
||||
targetMock.VerifySet(t => t.TensionForULS = It.IsAny<bool>(), Times.Never);
|
||||
targetMock.VerifySet(t => t.TensionForSLS = It.IsAny<bool>(), Times.Never);
|
||||
targetMock.VerifySet(t => t.RelativeHumidity = It.IsAny<double>(), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldThrowStructureHelperException_WhenObjectsAreOfDifferentTypes()
|
||||
{
|
||||
// Arrange
|
||||
var targetMock = new Mock<IConcreteLibMaterial>();
|
||||
var sourceMock = new Mock<ConcreteLibMaterial>();
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => strategy.Update(targetMock.Object, sourceMock.Object));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,104 @@
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using StructureHelperCommon.Infrastructures.Exceptions;
|
||||
using StructureHelperCommon.Infrastructures.Interfaces;
|
||||
using StructureHelperLogics.NdmCalculations.Cracking;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
|
||||
{
|
||||
|
||||
|
||||
[TestFixture]
|
||||
public class CrackCalculatorUpdateStrategyTests
|
||||
{
|
||||
private Mock<IUpdateStrategy<ICrackCalculatorInputData>> _inputDataUpdateStrategyMock;
|
||||
private CrackCalculatorUpdateStrategy _crackCalculatorUpdateStrategy;
|
||||
|
||||
[SetUp]
|
||||
public void SetUp()
|
||||
{
|
||||
_inputDataUpdateStrategyMock = new Mock<IUpdateStrategy<ICrackCalculatorInputData>>();
|
||||
_crackCalculatorUpdateStrategy = new CrackCalculatorUpdateStrategy(_inputDataUpdateStrategyMock.Object);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WhenTargetAndSourceAreSameObject_DoesNotCallInputDataUpdateStrategy()
|
||||
{
|
||||
// Arrange
|
||||
var calculator = new Mock<ICrackCalculator>().Object;
|
||||
|
||||
// Act
|
||||
_crackCalculatorUpdateStrategy.Update(calculator, calculator);
|
||||
|
||||
// Assert
|
||||
_inputDataUpdateStrategyMock.Verify(s => s.Update(It.IsAny<ICrackCalculatorInputData>(), It.IsAny<ICrackCalculatorInputData>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WhenSourceObjectIsNull_ThrowsArgumentNullException()
|
||||
{
|
||||
// Arrange
|
||||
var targetObject = new Mock<ICrackCalculator>().Object;
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => _crackCalculatorUpdateStrategy.Update(targetObject, null));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WhenTargetObjectIsNull_ThrowsArgumentNullException()
|
||||
{
|
||||
// Arrange
|
||||
var sourceObject = new Mock<ICrackCalculator>().Object;
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => _crackCalculatorUpdateStrategy.Update(null, sourceObject));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_UpdatesTargetObjectNameAndCallsInputDataUpdateStrategy()
|
||||
{
|
||||
// Arrange
|
||||
var targetObject = new Mock<ICrackCalculator>();
|
||||
var sourceObject = new Mock<ICrackCalculator>();
|
||||
|
||||
var targetInputData = new Mock<ICrackCalculatorInputData>().Object;
|
||||
var sourceInputData = new Mock<ICrackCalculatorInputData>().Object;
|
||||
|
||||
targetObject.SetupAllProperties();
|
||||
targetObject.Object.InputData = targetInputData;
|
||||
sourceObject.SetupAllProperties();
|
||||
sourceObject.Object.InputData = sourceInputData;
|
||||
sourceObject.Setup(x => x.Name).Returns("Source Name");
|
||||
|
||||
// Act
|
||||
_crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
|
||||
|
||||
// Assert
|
||||
Assert.AreEqual("Source Name", targetObject.Object.Name);
|
||||
_inputDataUpdateStrategyMock.Verify(s => s.Update(targetInputData, sourceInputData), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WhenTargetInputDataIsNull_CreatesNewInputDataAndUpdatesIt()
|
||||
{
|
||||
// Arrange
|
||||
var targetObject = new Mock<ICrackCalculator>();
|
||||
var sourceObject = new Mock<ICrackCalculator>();
|
||||
|
||||
var sourceInputData = new Mock<ICrackCalculatorInputData>().Object;
|
||||
|
||||
targetObject.SetupAllProperties();
|
||||
targetObject.Object.InputData = null;
|
||||
sourceObject.SetupAllProperties();
|
||||
sourceObject.Object.InputData = sourceInputData;
|
||||
|
||||
// Act
|
||||
_crackCalculatorUpdateStrategy.Update(targetObject.Object, sourceObject.Object);
|
||||
|
||||
// Assert
|
||||
Assert.IsNotNull(targetObject.Object.InputData);
|
||||
_inputDataUpdateStrategyMock.Verify(s => s.Update(targetObject.Object.InputData, sourceInputData), Times.Once);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,89 @@
|
||||
using Moq;
|
||||
using NUnit.Framework;
|
||||
using StructureHelperCommon.Infrastructures.Exceptions;
|
||||
using StructureHelperCommon.Infrastructures.Interfaces;
|
||||
using StructureHelperCommon.Models.Forces;
|
||||
using StructureHelperLogics.NdmCalculations.Cracking;
|
||||
using StructureHelperLogics.NdmCalculations.Primitives;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
|
||||
{
|
||||
|
||||
[TestFixture]
|
||||
public class CrackInputDataUpdateStrategyTests
|
||||
{
|
||||
[Test]
|
||||
public void Update_WithValidInput_UpdatesTargetObject()
|
||||
{
|
||||
// Arrange
|
||||
var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
|
||||
var targetObject = new Mock<ICrackCalculatorInputData>();
|
||||
var sourceObject = new Mock<ICrackCalculatorInputData>();
|
||||
|
||||
var forceActions = new List<IForceAction> { new Mock<IForceAction>().Object };
|
||||
var primitives = new List<INdmPrimitive> { new Mock<INdmPrimitive>().Object };
|
||||
var userCrackInputData = new Mock<IUserCrackInputData>();
|
||||
|
||||
sourceObject.Setup(s => s.ForceActions).Returns(forceActions);
|
||||
sourceObject.Setup(s => s.Primitives).Returns(primitives);
|
||||
sourceObject.Setup(s => s.UserCrackInputData).Returns(userCrackInputData.Object);
|
||||
|
||||
targetObject.Setup(t => t.ForceActions).Returns(new List<IForceAction>());
|
||||
targetObject.Setup(t => t.Primitives).Returns(new List<INdmPrimitive>());
|
||||
targetObject.SetupProperty(t => t.UserCrackInputData, new Mock<IUserCrackInputData>().Object);
|
||||
|
||||
var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
|
||||
|
||||
// Act
|
||||
strategy.Update(targetObject.Object, sourceObject.Object);
|
||||
|
||||
// Assert
|
||||
Assert.AreEqual(forceActions, targetObject.Object.ForceActions);
|
||||
Assert.AreEqual(primitives, targetObject.Object.Primitives);
|
||||
mockUserCrackInputDataUpdateStrategy.Verify(s => s.Update(It.IsAny<IUserCrackInputData>(), It.IsAny<IUserCrackInputData>()), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WhenTargetAndSourceAreSame_DoesNotUpdate()
|
||||
{
|
||||
// Arrange
|
||||
var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
|
||||
var targetObject = new Mock<ICrackCalculatorInputData>();
|
||||
|
||||
var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
|
||||
|
||||
// Act
|
||||
strategy.Update(targetObject.Object, targetObject.Object);
|
||||
|
||||
// Assert
|
||||
mockUserCrackInputDataUpdateStrategy.Verify(s => s.Update(It.IsAny<IUserCrackInputData>(), It.IsAny<IUserCrackInputData>()), Times.Never);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WithNullTarget_ThrowsStructureHelperException()
|
||||
{
|
||||
// Arrange
|
||||
var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
|
||||
var sourceObject = new Mock<ICrackCalculatorInputData>();
|
||||
|
||||
var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => strategy.Update(null, sourceObject.Object));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_WithNullSource_ThrowsStructureHelperException()
|
||||
{
|
||||
// Arrange
|
||||
var mockUserCrackInputDataUpdateStrategy = new Mock<IUpdateStrategy<IUserCrackInputData>>();
|
||||
var targetObject = new Mock<ICrackCalculatorInputData>();
|
||||
|
||||
var strategy = new CrackInputDataUpdateStrategy(mockUserCrackInputDataUpdateStrategy.Object);
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => strategy.Update(targetObject.Object, null));
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,98 @@
|
||||
using NUnit.Framework;
|
||||
using Moq;
|
||||
using StructureHelperCommon.Infrastructures.Exceptions;
|
||||
using StructureHelperCommon.Models.Materials.Libraries;
|
||||
using StructureHelperCommon.Models.Materials;
|
||||
using StructureHelperLogics.Models.Materials;
|
||||
|
||||
namespace StructureHelperTests.UnitTests.UpdateStrategiesTests
|
||||
{
|
||||
|
||||
|
||||
[TestFixture]
|
||||
public class LibMaterialUpdateStrategyTests
|
||||
{
|
||||
private Mock<ILibMaterial> mockTargetMaterial;
|
||||
private Mock<ILibMaterial> mockSourceMaterial;
|
||||
private LibMaterialUpdateStrategy updateStrategy;
|
||||
|
||||
[SetUp]
|
||||
public void Setup()
|
||||
{
|
||||
mockTargetMaterial = new Mock<ILibMaterial>();
|
||||
mockSourceMaterial = new Mock<ILibMaterial>();
|
||||
updateStrategy = new LibMaterialUpdateStrategy();
|
||||
|
||||
var targetSafetyFactors = new List<IMaterialSafetyFactor>();
|
||||
mockTargetMaterial.Setup(t => t.SafetyFactors).Returns(targetSafetyFactors);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldThrowException_WhenTargetAndSourceAreDifferentTypes()
|
||||
{
|
||||
// Arrange
|
||||
var mockTarget1 = new ConcreteLibMaterial();
|
||||
var mockTarget2 = new ReinforcementLibMaterial();
|
||||
|
||||
// Act & Assert
|
||||
Assert.Throws<StructureHelperException>(() => updateStrategy.Update(mockTarget1, mockTarget2));
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldCopyMaterialEntityAndMaterialLogic()
|
||||
{
|
||||
// Arrange
|
||||
var materialEntity = new Mock<ILibMaterialEntity>().Object;
|
||||
var materialLogic = new Mock<IMaterialLogic>().Object;
|
||||
|
||||
mockSourceMaterial.Setup(s => s.MaterialEntity).Returns(materialEntity);
|
||||
mockSourceMaterial.Setup(s => s.MaterialLogic).Returns(materialLogic);
|
||||
|
||||
// Act
|
||||
updateStrategy.Update(mockTargetMaterial.Object, mockSourceMaterial.Object);
|
||||
|
||||
// Assert
|
||||
mockTargetMaterial.VerifySet(t => t.MaterialEntity = materialEntity, Times.Once);
|
||||
mockTargetMaterial.VerifySet(t => t.MaterialLogic = materialLogic, Times.Once);
|
||||
}
|
||||
|
||||
//[Test]
|
||||
public void Update_ShouldClearAndCopySafetyFactors()
|
||||
{
|
||||
// Arrange
|
||||
var mockSafetyFactor1 = new Mock<IMaterialSafetyFactor>();
|
||||
var mockSafetyFactor2 = new Mock<IMaterialSafetyFactor>();
|
||||
var safetyFactors = new List<IMaterialSafetyFactor> { mockSafetyFactor1.Object, mockSafetyFactor2.Object };
|
||||
var targetSafetyFactors = new List<IMaterialSafetyFactor>();
|
||||
|
||||
mockSourceMaterial.Setup(s => s.SafetyFactors).Returns(safetyFactors);
|
||||
mockSafetyFactor1.Setup(f => f.Clone()).Returns(mockSafetyFactor1.Object);
|
||||
mockSafetyFactor2.Setup(f => f.Clone()).Returns(mockSafetyFactor2.Object);
|
||||
|
||||
mockTargetMaterial.Setup(t => t.SafetyFactors).Returns(targetSafetyFactors);
|
||||
|
||||
// Act
|
||||
updateStrategy.Update(mockTargetMaterial.Object, mockSourceMaterial.Object);
|
||||
|
||||
// Assert
|
||||
//mockTargetMaterial.Verify(t => t.SafetyFactors.Clear(), Times.Once);
|
||||
//mockTargetMaterial.Verify(t => t.SafetyFactors.Add(mockSafetyFactor1.Object), Times.Once);
|
||||
//mockTargetMaterial.Verify(t => t.SafetyFactors.Add(mockSafetyFactor2.Object), Times.Once);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Update_ShouldNotPerformUpdate_WhenObjectsAreReferenceEqual()
|
||||
{
|
||||
//Arrange
|
||||
|
||||
// Act
|
||||
updateStrategy.Update(mockTargetMaterial.Object, mockTargetMaterial.Object);
|
||||
|
||||
// Assert
|
||||
mockTargetMaterial.VerifySet(t => t.MaterialEntity = It.IsAny<ILibMaterialEntity>(), Times.Never);
|
||||
//mockTargetMaterial.Verify(t => t.SafetyFactors.Clear(), Times.Never);
|
||||
mockTargetMaterial.VerifySet(t => t.MaterialLogic = It.IsAny<IMaterialLogic>(), Times.Never);
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
Reference in New Issue
Block a user