public void Create_WithSurfaceLines_ReturnFailureMechanismEntityWithSurfaceLineEntities()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsSurfaceLineCollection surfaceLines = failureMechanism.SurfaceLines;
surfaceLines.AddRange(new[]
{
CreateSurfaceLine(new Random(31))
}, "path");
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(surfaceLines.Count, entity.SurfaceLineEntities.Count);
for (var i = 0; i < surfaceLines.Count; i++)
{
AssertSurfaceLine(surfaceLines[i], entity.SurfaceLineEntities.ElementAt(i));
}
string surfaceLineCollectionSourcePath = entity.MacroStabilityInwardsFailureMechanismMetaEntities
.Single()
.SurfaceLineCollectionSourcePath;
TestHelper.AssertAreEqualButNotSame(surfaceLines.SourcePath, surfaceLineCollectionSourcePath);
}
public void Create_WithoutAllPropertiesSet_ReturnsFailureMechanismEntityWithPropertiesSet()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual((short)FailureMechanismType.MacroStabilityInwards, entity.FailureMechanismType);
Assert.AreEqual(Convert.ToByte(failureMechanism.InAssembly), entity.InAssembly);
Assert.AreEqual(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
Assert.AreEqual(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
Assert.AreEqual(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
Assert.AreEqual(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
Assert.AreEqual(failureMechanism.FailureMechanismSectionSourcePath, entity.FailureMechanismSectionCollectionSourcePath);
CollectionAssert.IsEmpty(entity.StochasticSoilModelEntities);
MacroStabilityInwardsFailureMechanismMetaEntity failureMechanismMetaEntity = entity.MacroStabilityInwardsFailureMechanismMetaEntities.Single();
Assert.AreEqual(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.A, failureMechanismMetaEntity.A);
Assert.AreEqual(failureMechanism.SurfaceLines.SourcePath, failureMechanismMetaEntity.SurfaceLineCollectionSourcePath);
Assert.AreEqual(failureMechanism.StochasticSoilModels.SourcePath, failureMechanismMetaEntity.StochasticSoilModelCollectionSourcePath);
}
public void Create_WithStochasticSoilModels_ReturnsFailureMechanismEntityWithStochasticSoilModelEntities()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
MacroStabilityInwardsStochasticSoilModelCollection stochasticSoilModels = failureMechanism.StochasticSoilModels;
stochasticSoilModels.AddRange(new[]
{
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name"),
MacroStabilityInwardsStochasticSoilModelTestFactory.CreateValidStochasticSoilModel("name2")
}, "some/path/to/file");
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(stochasticSoilModels.Count, entity.StochasticSoilModelEntities.Count);
for (var i = 0; i < stochasticSoilModels.Count; i++)
{
AssertStochasticSoilModel(stochasticSoilModels[i],
entity.StochasticSoilModelEntities.ElementAt(i));
}
string stochasticSoilModelCollectionSourcePath = entity.MacroStabilityInwardsFailureMechanismMetaEntities
.Single()
.StochasticSoilModelCollectionSourcePath;
TestHelper.AssertAreEqualButNotSame(stochasticSoilModels.SourcePath, stochasticSoilModelCollectionSourcePath);
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism
{
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
CalculationsInputComments =
{
Body = "Some calculation text"
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
TestHelper.AssertAreEqualButNotSame(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
// Call
TestDelegate test = () => failureMechanism.Create(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("registry", paramName);
}
public void Create_WithoutSections_EmptyFailureMechanismSectionEntities()
{
// Setup
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.IsNotNull(entity);
CollectionAssert.IsEmpty(entity.FailureMechanismSectionEntities);
Assert.IsNull(entity.FailureMechanismSectionCollectionSourcePath);
}
public void Create_WithPropertiesSet_ReturnsFailureMechanismEntityWithPropertiesSet()
{
// Setup
var random = new Random(31);
var failureMechanism = new MacroStabilityInwardsFailureMechanism
{
InAssembly = random.NextBoolean(),
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
},
CalculationsInputComments =
{
Body = "Some calculation text"
},
MacroStabilityInwardsProbabilityAssessmentInput =
{
A = random.NextDouble()
}
};
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual((short)FailureMechanismType.MacroStabilityInwards, entity.FailureMechanismType);
Assert.AreEqual(Convert.ToByte(failureMechanism.InAssembly), entity.InAssembly);
Assert.AreEqual(failureMechanism.InAssemblyInputComments.Body, entity.InAssemblyInputComments);
Assert.AreEqual(failureMechanism.InAssemblyOutputComments.Body, entity.InAssemblyOutputComments);
Assert.AreEqual(failureMechanism.NotInAssemblyComments.Body, entity.NotInAssemblyComments);
Assert.AreEqual(failureMechanism.CalculationsInputComments.Body, entity.CalculationsInputComments);
CollectionAssert.IsEmpty(entity.StochasticSoilModelEntities);
CollectionAssert.IsEmpty(entity.SurfaceLineEntities);
MacroStabilityInwardsFailureMechanismMetaEntity failureMechanismMetaEntity = entity.MacroStabilityInwardsFailureMechanismMetaEntities.Single();
Assert.AreEqual(failureMechanism.MacroStabilityInwardsProbabilityAssessmentInput.A, failureMechanismMetaEntity.A);
Assert.AreEqual(failureMechanism.SurfaceLines.SourcePath, failureMechanismMetaEntity.SurfaceLineCollectionSourcePath);
Assert.AreEqual(failureMechanism.StochasticSoilModels.SourcePath, failureMechanismMetaEntity.StochasticSoilModelCollectionSourcePath);
}
/// <summary>
/// Creates a <see cref="FailureMechanismEntity"/> based on the information of the <see cref="MacroStabilityInwardsFailureMechanism"/>.
/// </summary>
/// <param name="mechanism">The failure mechanism to create a database entity for.</param>
/// <param name="registry">The object keeping track of create operations.</param>
/// <returns>A new <see cref="FailureMechanismEntity"/>.</returns>
/// <exception cref="ArgumentNullException">Thrown when <paramref name="registry"/> is <c>null</c>.</exception>
public static FailureMechanismEntity Create(this MacroStabilityInwardsFailureMechanism mechanism,
PersistenceRegistry registry)
{
FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.MacroStabilityInwards, registry);
AddEntitiesForFailureMechanismMeta(mechanism, entity);
AddEntitiesForStochasticSoilModels(mechanism, registry, entity);
AddEntitiesForSurfaceLines(mechanism, registry, entity);
AddEntitiesForSectionResults(mechanism.SectionResults, registry);
entity.CalculationGroupEntity = mechanism.CalculationsGroup.Create(registry, 0);
return(entity);
}
public void Create_WithSections_FailureMechanismSectionEntitiesCreated()
{
// Setup
const string filePath = "failureMechanismSections/file/path";
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
FailureMechanismSection testFailureMechanismSection = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
failureMechanism.SetSections(new[]
{
testFailureMechanismSection
}, filePath);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
Assert.AreEqual(1, entity.FailureMechanismSectionEntities
.SelectMany(fms => fms.AdoptableWithProfileProbabilityFailureMechanismSectionResultEntities)
.Count());
TestHelper.AssertAreEqualButNotSame(filePath, entity.FailureMechanismSectionCollectionSourcePath);
}
public void Create_WithCalculationGroup_ReturnFailureMechanismWithCalculationGroupEntities()
{
// Setup
var calculationGroup = new CalculationGroup();
var calculation = new MacroStabilityInwardsCalculationScenario();
var failureMechanism = new MacroStabilityInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
failureMechanism.CalculationsGroup.Children.Add(calculation);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.IsNotNull(entity);
Assert.AreEqual(failureMechanism.CalculationsGroup.Name, entity.CalculationGroupEntity.Name);
Assert.AreEqual(0, entity.CalculationGroupEntity.Order);
CalculationGroupEntity[] childGroupEntities = entity.CalculationGroupEntity.CalculationGroupEntity1
.OrderBy(cge => cge.Order)
.ToArray();
Assert.AreEqual(1, childGroupEntities.Length);
CalculationGroupEntity childGroupEntity = childGroupEntities[0];
Assert.AreEqual(calculationGroup.Name, childGroupEntity.Name);
Assert.AreEqual(0, childGroupEntity.Order);
MacroStabilityInwardsCalculationEntity[] calculationEntities = entity.CalculationGroupEntity.MacroStabilityInwardsCalculationEntities
.OrderBy(ce => ce.Order)
.ToArray();
Assert.AreEqual(1, calculationEntities.Length);
MacroStabilityInwardsCalculationEntity calculationEntity = calculationEntities[0];
Assert.AreEqual(calculation.Name, calculationEntity.Name);
Assert.AreEqual(1, calculationEntity.Order);
}