public void Create_WithValidData_ReturnsPersistableCalculationSettingsCollection()
{
// Setup
MacroStabilityInwardsSlidingCurve slidingCurve = MacroStabilityInwardsOutputTestFactory.CreateOutput().SlidingCurve;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
// Call
IEnumerable <PersistableCalculationSettings> settingsCollection = PersistableCalculationSettingsFactory.Create(slidingCurve, idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertCalculationSettings(slidingCurve, settingsCollection);
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
Assert.AreEqual(2, registry.Settings.Count);
for (var i = 0; i < stages.Length; i++)
{
Assert.AreEqual(registry.Settings[stages[i]], settingsCollection.ElementAt(i).Id);
}
}
public void Create_WithValidData_ReturnsPersistableStates()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
MacroStabilityInwardsStochasticSoilProfile stochasticSoilProfile = MacroStabilityInwardsStochasticSoilProfileTestFactory.CreateMacroStabilityInwardsStochasticSoilProfile2D(new[]
{
MacroStabilityInwardsPreconsolidationStressTestFactory.CreateMacroStabilityInwardsPreconsolidationStress(new Point2D(2, 1))
});
IMacroStabilityInwardsSoilLayer lastLayer = stochasticSoilProfile.SoilProfile.Layers.Last();
lastLayer.Data.UsePop = true;
lastLayer.Data.Pop = new VariationCoefficientLogNormalDistribution
{
Mean = (RoundedDouble)1,
CoefficientOfVariation = (RoundedDouble)2
};
calculation.InputParameters.StochasticSoilProfile = stochasticSoilProfile;
IMacroStabilityInwardsSoilProfileUnderSurfaceLine soilProfile = calculation.InputParameters.SoilProfileUnderSurfaceLine;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableState> states = PersistableStateFactory.Create(soilProfile, idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertStates(soilProfile, states);
PersistableState state = states.First();
Assert.AreEqual(registry.States[MacroStabilityInwardsExportStageType.Daily], state.Id);
}
public void Create_WithWaternetsWithoutLines_ReturnsPersistableWaternetCollection()
{
// Setup
var dailyWaternet = new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0], new MacroStabilityInwardsWaternetLine[0]);
var extremeWaternet = new MacroStabilityInwardsWaternet(new MacroStabilityInwardsPhreaticLine[0], new MacroStabilityInwardsWaternetLine[0]);
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
// Call
IEnumerable <PersistableWaternet> persistableWaternets = PersistableWaternetFactory.Create(dailyWaternet, extremeWaternet, new GeneralMacroStabilityInwardsInput(), idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertWaternets(new[]
{
dailyWaternet,
extremeWaternet
}, persistableWaternets);
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
Assert.AreEqual(2, registry.Waternets.Count);
for (var i = 0; i < stages.Length; i++)
{
Assert.AreEqual(registry.Waternets[stages[i]], persistableWaternets.ElementAt(i).Id);
}
}
public void Create_WithSoilProfile_ReturnsPersistableSoilCollection(MacroStabilityInwardsShearStrengthModel shearStrengthModel)
{
// Setup
var soilProfile = new MacroStabilityInwardsSoilProfileUnderSurfaceLine(
new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D()
})
},
Enumerable.Empty <IMacroStabilityInwardsPreconsolidationStress>());
var registry = new MacroStabilityInwardsExportRegistry();
IEnumerable <MacroStabilityInwardsSoilLayer2D> originalLayers = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers);
originalLayers.ForEachElementDo(layer => layer.Data.ShearStrengthModel = shearStrengthModel);
// Call
PersistableSoilCollection soilCollection = PersistableSoilCollectionFactory.Create(soilProfile, new IdFactory(), registry);
// Assert
IEnumerable <PersistableSoil> actualSoils = soilCollection.Soils;
PersistableDataModelTestHelper.AssertPersistableSoils(originalLayers, actualSoils);
Assert.AreEqual(actualSoils.Count(), registry.Soils.Count);
for (var i = 0; i < originalLayers.Count(); i++)
{
KeyValuePair <MacroStabilityInwardsSoilLayer2D, string> registrySoil = registry.Soils.ElementAt(i);
Assert.AreSame(originalLayers.ElementAt(i), registrySoil.Key);
Assert.AreEqual(actualSoils.ElementAt(i).Id, registrySoil.Value);
}
}
public void Create_WithValidData_ReturnsPersistableWaternetCreatorSettingsCollection()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
RoundedDouble normativeAssessmentLevel = RoundedDouble.NaN;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(input.SoilProfileUnderSurfaceLine, idFactory, registry);
// Call
IEnumerable <PersistableWaternetCreatorSettings> waternetCreatorSettingsCollection = PersistableWaternetCreatorSettingsFactory.Create(input, normativeAssessmentLevel,
idFactory, registry);
// Assert
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
PersistableDataModelTestHelper.AssertWaternetCreatorSettings(input, waternetCreatorSettingsCollection, normativeAssessmentLevel, stages);
AssertRegistry(registry, stages, waternetCreatorSettingsCollection);
}
public void Create_WithValidData_ReturnsPersistableProjectInfo()
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
const string filePath = "SomeFilePath";
// Call
PersistableProjectInfo persistableProjectInfo = PersistableProjectInfoFactory.Create(calculation, filePath);
// Assert
PersistableDataModelTestHelper.AssertProjectInfo(calculation, filePath, persistableProjectInfo);
}
public void Create_WithValidData_ReturnsPersistableDataModel()
{
// Setup
const string filePath = "ValidFilePath";
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
PersistableDataModel persistableDataModel = PersistableDataModelFactory.Create(calculation, new GeneralMacroStabilityInwardsInput(), AssessmentSectionTestHelper.GetTestAssessmentLevel, filePath);
// Assert
PersistableDataModelTestHelper.AssertPersistableDataModel(calculation, filePath, persistableDataModel);
}
}
public void Create_WithDistribution_ReturnsPersistableStochasticParameter()
{
// Setup
var mocks = new MockRepository();
var distribution = mocks.Stub <IVariationCoefficientDistribution>();
mocks.ReplayAll();
var random = new Random(21);
distribution.Mean = random.NextRoundedDouble();
distribution.CoefficientOfVariation = random.NextRoundedDouble();
// Call
PersistableStochasticParameter stochasticParameter = PersistableStochasticParameterFactory.Create(distribution);
// Assert
PersistableDataModelTestHelper.AssertStochasticParameter(distribution, stochasticParameter);
mocks.VerifyAll();
}
public void Create_WithValidData_ReturnsNull()
{
// Setup
var soilProfile = new MacroStabilityInwardsSoilProfileUnderSurfaceLine(new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D()
})
}, Enumerable.Empty <IMacroStabilityInwardsPreconsolidationStress>());
var registry = new MacroStabilityInwardsExportRegistry();
// Call
IEnumerable <PersistableGeometry> geometries = PersistableGeometryFactory.Create(soilProfile, new IdFactory(), registry);
// Assert
IEnumerable <MacroStabilityInwardsSoilLayer2D> layersRecursively = MacroStabilityInwardsSoilProfile2DLayersHelper.GetLayersRecursively(soilProfile.Layers);
PersistableDataModelTestHelper.AssertPersistableGeometry(layersRecursively, geometries);
AssertRegistry(registry, geometries, layersRecursively);
}
public void Create_WithValidData_ReturnsPersistableSoilLayerCollectionCollection()
{
// Setup
var soilProfile = new MacroStabilityInwardsSoilProfileUnderSurfaceLine(
new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D(new[]
{
MacroStabilityInwardsSoilLayer2DTestFactory.CreateMacroStabilityInwardsSoilLayer2D()
})
},
Enumerable.Empty <IMacroStabilityInwardsPreconsolidationStress>());
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableSoilCollection soils = PersistableSoilCollectionFactory.Create(soilProfile, idFactory, registry);
IEnumerable <PersistableGeometry> geometries = PersistableGeometryFactory.Create(soilProfile, idFactory, registry);
// Call
IEnumerable <PersistableSoilLayerCollection> soilLayerCollections = PersistableSoilLayerCollectionFactory.Create(soilProfile, idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertPersistableSoilLayers(soilProfile.Layers, soilLayerCollections, soils.Soils, geometries);
var stages = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
Assert.AreEqual(2, registry.SoilLayers.Count);
for (var i = 0; i < stages.Length; i++)
{
Assert.AreEqual(registry.SoilLayers[stages[i]], soilLayerCollections.ElementAt(i).Id);
}
}
public void Create_WithDifferentCharacteristics_ReturnsPersistableWaternetCreatorSettingsCollection([Values(true, false)] bool isDitchPresent,
[Values(true, false)] bool isShouldBaseInsidePresent)
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
if (isDitchPresent)
{
input.SurfaceLine.SetDitchPolderSideAt(new Point3D(0.1, 0, 2));
input.SurfaceLine.SetBottomDitchPolderSideAt(new Point3D(0.2, 0, 2));
input.SurfaceLine.SetBottomDitchDikeSideAt(new Point3D(0.3, 0, 3));
input.SurfaceLine.SetDitchDikeSideAt(new Point3D(0.4, 0, 3));
}
if (isShouldBaseInsidePresent)
{
input.SurfaceLine.SetShoulderBaseInsideAt(new Point3D(0.5, 0, 1));
}
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(input.SoilProfileUnderSurfaceLine, idFactory, registry);
// Call
IEnumerable <PersistableWaternetCreatorSettings> waternetCreatorSettingsCollection = PersistableWaternetCreatorSettingsFactory.Create(
input, RoundedDouble.NaN, idFactory, registry);
// Assert
foreach (PersistableWaternetCreatorSettings waternetCreatorSettings in waternetCreatorSettingsCollection)
{
Assert.AreEqual(isDitchPresent, waternetCreatorSettings.IsDitchPresent);
PersistableDataModelTestHelper.AssertDitchCharacteristics(input.SurfaceLine, waternetCreatorSettings.DitchCharacteristics, isDitchPresent);
PersistableDataModelTestHelper.AssertEmbankmentCharacteristics(input.SurfaceLine, waternetCreatorSettings.EmbankmentCharacteristics);
}
}
public void Export_RunsSuccessful_SetsDataCorrectlyAndReturnsTrue()
{
// Setup
string filePath = TestHelper.GetScratchPadPath($"{nameof(MacroStabilityInwardsCalculationExporterTest)}.{nameof(Export_RunsSuccessful_SetsDataCorrectlyAndReturnsTrue)}.ValidFile.stix");
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(new TestHydraulicBoundaryLocation());
calculation.Output = MacroStabilityInwardsOutputTestFactory.CreateRandomOutput();
var persistenceFactory = new MacroStabilityInwardsTestPersistenceFactory
{
WriteFile = true
};
var exporter = new MacroStabilityInwardsCalculationExporter(calculation, new GeneralMacroStabilityInwardsInput(), persistenceFactory, filePath, AssessmentSectionTestHelper.GetTestAssessmentLevel);
try
{
using (new MacroStabilityInwardsCalculatorFactoryConfig())
{
// Call
bool exportResult = exporter.Export();
// Assert
PersistableDataModelTestHelper.AssertPersistableDataModel(calculation, filePath, persistenceFactory.PersistableDataModel);
Assert.AreEqual($"{filePath}.temp", persistenceFactory.FilePath);
var persister = (MacroStabilityInwardsTestPersister)persistenceFactory.CreatedPersister;
Assert.IsTrue(persister.PersistCalled);
Assert.IsTrue(exportResult);
}
}
finally
{
File.Delete(filePath);
}
}
public void Create_WithDifferentDikeSoilScenarios_ReturnsPersistableWaternetCreatorSettingsCollection(MacroStabilityInwardsDikeSoilScenario soilScenario)
{
// Setup
MacroStabilityInwardsCalculationScenario calculation = MacroStabilityInwardsCalculationScenarioTestFactory.CreateMacroStabilityInwardsCalculationScenarioWithValidInput(
new TestHydraulicBoundaryLocation());
MacroStabilityInwardsInput input = calculation.InputParameters;
input.DikeSoilScenario = soilScenario;
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
PersistableGeometryFactory.Create(input.SoilProfileUnderSurfaceLine, idFactory, registry);
// Call
IEnumerable <PersistableWaternetCreatorSettings> waternetCreatorSettingsCollection = PersistableWaternetCreatorSettingsFactory.Create(
input, RoundedDouble.NaN, idFactory, registry);
// Assert
foreach (PersistableWaternetCreatorSettings waternetCreatorSettings in waternetCreatorSettingsCollection)
{
Assert.AreEqual(PersistableDataModelTestHelper.GetEmbankmentSoilScenario(input.DikeSoilScenario), waternetCreatorSettings.EmbankmentSoilScenario);
}
}
public void Create_WithValidData_ReturnsStages()
{
// Setup
var idFactory = new IdFactory();
var registry = new MacroStabilityInwardsExportRegistry();
var stageTypes = new[]
{
MacroStabilityInwardsExportStageType.Daily,
MacroStabilityInwardsExportStageType.Extreme
};
var settingsList = new List <PersistableCalculationSettings>();
var geometryList = new List <PersistableGeometry>();
var soilLayersList = new List <PersistableSoilLayerCollection>();
var waternetList = new List <PersistableWaternet>();
var waternetCreatorSettingsList = new List <PersistableWaternetCreatorSettings>();
var stateList = new List <PersistableState>();
foreach (MacroStabilityInwardsExportStageType stageType in stageTypes)
{
var settings = new PersistableCalculationSettings
{
Id = idFactory.Create()
};
settingsList.Add(settings);
var geometry = new PersistableGeometry
{
Id = idFactory.Create()
};
geometryList.Add(geometry);
var persistableSoilLayerCollection = new PersistableSoilLayerCollection
{
Id = idFactory.Create()
};
soilLayersList.Add(persistableSoilLayerCollection);
var waternet = new PersistableWaternet
{
Id = idFactory.Create()
};
waternetList.Add(waternet);
var waternetCreatorSettings = new PersistableWaternetCreatorSettings
{
Id = idFactory.Create()
};
waternetCreatorSettingsList.Add(waternetCreatorSettings);
var state = new PersistableState
{
Id = idFactory.Create()
};
stateList.Add(state);
registry.AddSettings(stageType, settings.Id);
registry.AddGeometry(stageType, geometry.Id);
registry.AddSoilLayer(stageType, persistableSoilLayerCollection.Id);
registry.AddWaternet(stageType, waternet.Id);
registry.AddWaternetCreatorSettings(stageType, waternetCreatorSettings.Id);
registry.AddState(stageType, state.Id);
}
// Call
IEnumerable <PersistableStage> stages = PersistableStageFactory.Create(idFactory, registry);
// Assert
PersistableDataModelTestHelper.AssertStages(stages, settingsList, geometryList, soilLayersList, waternetList, waternetCreatorSettingsList, stateList);
}
