public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var calculationGroup = new CalculationGroup();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[]
{
failureMechanism
});
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(new HydraulicBoundaryDatabase
{
Locations =
{
new HydraulicBoundaryLocation(1, "Location 1", 1.1, 2.2),
new HydraulicBoundaryLocation(2, "Location 2", 3.3, 4.4)
}
});
mocks.ReplayAll();
using (var view = new GrassCoverErosionInwardsCalculationsView(calculationGroup, failureMechanism, assessmentSection))
{
view.Data = failureMechanism.CalculationsGroup;
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
public void VerifyUpdates_CalculationWithoutOutputs_ReturnsTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var mainWindow = mocks.Stub <IMainWindow>();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
mocks.ReplayAll();
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
plugin.Gui = gui;
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
var dikeProfiles = new DikeProfileCollection();
var context = new DikeProfilesContext(dikeProfiles, failureMechanism, assessmentSection);
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
bool updatesVerified = updateInfo.VerifyUpdates(context);
// Assert
Assert.IsTrue(updatesVerified);
mocks.VerifyAll();
}
}
public void IsEnabled_DikeProfileCollectionSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(new ReferenceLine());
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var dikeProfiles = new DikeProfileCollection();
dikeProfiles.AddRange(Enumerable.Empty <DikeProfile>(), "some/path");
var context = new DikeProfilesContext(dikeProfiles, failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void FailureMechanismResultsView_AllDataSet_SetsCorrectInputOnCalculator()
{
// Setup
FailureMechanismSection section = FailureMechanismSectionTestFactory.CreateFailureMechanismSection();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
FailureMechanismTestHelper.SetSections(failureMechanism, new[]
{
section
});
var assessmentSection = new AssessmentSectionStub();
// Call
using (new AssemblyToolCalculatorFactoryConfig())
using (ShowFailureMechanismResultsView(failureMechanism, assessmentSection))
{
// Assert
var testFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = testFactory.LastCreatedFailureMechanismAssemblyCalculator;
Assert.AreEqual(failureMechanism.GeneralInput.N, calculator.FailureMechanismN);
}
}
public void UpdateDikeProfilesWithImportedData_DikeProfilePropertiesChanged_UpdateRelevantProperties()
{
// Setup
DikeProfile dikeProfileToUpdate = DikeProfileTestFactory.CreateDikeProfile("name", "ID A");
DikeProfile dikeProfileToUpdateFrom = DeepCloneAndModify(dikeProfileToUpdate);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
DikeProfileCollection targetCollection = failureMechanism.DikeProfiles;
targetCollection.AddRange(new[]
{
dikeProfileToUpdate
}, sourceFilePath);
var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(failureMechanism);
// Call
strategy.UpdateDikeProfilesWithImportedData(new[]
{
dikeProfileToUpdateFrom
}, sourceFilePath);
// Assert
Assert.AreSame(dikeProfileToUpdate, targetCollection[0]);
AssertDikeProfile(dikeProfileToUpdateFrom, dikeProfileToUpdate);
}
public void ClearReferenceLineDependentData_FullyConfiguredFailureMechanism_RemoveFailureMechanismDependentData()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
object[] expectedRemovedObjectInstances = failureMechanism.Sections.OfType <object>()
.Concat(failureMechanism.SectionResults)
.Concat(failureMechanism.CalculationsGroup.GetAllChildrenRecursive())
.Concat(failureMechanism.DikeProfiles)
.ToArray();
// Call
ClearResults result = GrassCoverErosionInwardsDataSynchronizationService.ClearReferenceLineDependentData(failureMechanism);
// Assert
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
CollectionAssert.IsEmpty(failureMechanism.CalculationsGroup.Children);
CollectionAssert.IsEmpty(failureMechanism.DikeProfiles);
IObservable[] array = result.ChangedObjects.ToArray();
Assert.AreEqual(4, array.Length);
CollectionAssert.Contains(array, failureMechanism);
CollectionAssert.Contains(array, failureMechanism.SectionResults);
CollectionAssert.Contains(array, failureMechanism.CalculationsGroup);
CollectionAssert.Contains(array, failureMechanism.DikeProfiles);
CollectionAssert.AreEquivalent(expectedRemovedObjectInstances, result.RemovedObjects);
}
public void IsEnabled_ReferenceLineWithGeometry_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.ReferenceLine).Return(ReferenceLineTestFactory.CreateReferenceLineWithGeometry());
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var context = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
ImportInfo importInfo = GetImportInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseLinkedToInvalidFile_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(null, mocksRepository, "invalidFilePath");
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
ToolStripItem contextMenuItem = contextMenu.Items[contextMenuValidateAllIndex];
Assert.AreEqual("Alles &valideren", contextMenuItem.Text);
StringAssert.Contains("Herstellen van de verbinding met de hydraulische belastingendatabase is mislukt.", contextMenuItem.ToolTipText);
TestHelper.AssertImagesAreEqual(RiskeerCommonFormsResources.ValidateAllIcon, contextMenuItem.Image);
Assert.IsFalse(contextMenuItem.Enabled);
}
}
}
private void ShowGrassCoverErosionInwardsScenariosView(GrassCoverErosionInwardsFailureMechanism failureMechanism)
{
var scenariosView = new GrassCoverErosionInwardsScenariosView(failureMechanism.CalculationsGroup, failureMechanism);
testForm.Controls.Add(scenariosView);
testForm.Show();
}
public void ScenariosView_ImportFailureMechanismSections_ChangesCorrectlyObservedAndSynced()
{
// Setup
using (var form = new Form())
{
var assessmentSection = new AssessmentSection(AssessmentSectionComposition.Dike);
DataImportHelper.ImportReferenceLine(assessmentSection);
var view = new GrassCoverErosionInwardsScenariosView(assessmentSection.GrassCoverErosionInwards.CalculationsGroup,
assessmentSection.GrassCoverErosionInwards);
form.Controls.Add(view);
form.Show();
var listBox = (ListBox) new ControlTester("listBox").TheObject;
// Precondition
CollectionAssert.IsEmpty(listBox.Items);
// Call
GrassCoverErosionInwardsFailureMechanism failureMechanism = assessmentSection.GrassCoverErosionInwards;
DataImportHelper.ImportFailureMechanismSections(assessmentSection, failureMechanism);
assessmentSection.GrassCoverErosionInwards.NotifyObservers();
// Assert
CollectionAssert.AreEqual(assessmentSection.GrassCoverErosionInwards.Sections, listBox.Items);
}
}
public void ContextMenuStrip_HydraulicBoundaryDatabaseNotLinked_ContextMenuItemValidateAllDisabledAndTooltipSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new GrassCoverErosionInwardsCalculation());
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocksRepository);
var nodeData = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
using (var treeViewControl = new TreeViewControl())
{
var gui = mocksRepository.Stub <IGui>();
gui.Stub(g => g.Get(nodeData, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mocksRepository.Stub <IMainWindow>());
mocksRepository.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(nodeData, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Er is geen hydraulische belastingendatabase geïmporteerd.",
RiskeerCommonFormsResources.ValidateAllIcon,
false);
}
}
}
public void UpdateDikeProfilesWithImportedData_CollectionAndImportedDataCollectionNotEmpty_ReplacesCurrentWithImportedData()
{
// Setup
DikeProfile targetDikeProfile = DikeProfileTestFactory.CreateDikeProfile("Name A", "Name A ID");
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.DikeProfiles.AddRange(new[]
{
targetDikeProfile
}, sourceFilePath);
DikeProfile readDikeProfile = DikeProfileTestFactory.CreateDikeProfile("Name B", "Name B ID");
var strategy = new GrassCoverErosionInwardsDikeProfileReplaceDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateDikeProfilesWithImportedData(new[]
{
readDikeProfile
}, sourceFilePath);
// Assert
CollectionAssert.AreEqual(new[]
{
failureMechanism.DikeProfiles
}, affectedObjects);
DikeProfile[] expectedDikeProfiles =
{
readDikeProfile
};
CollectionAssert.AreEqual(expectedDikeProfiles, failureMechanism.DikeProfiles);
}
public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new GrassCoverErosionInwardsFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new GrassCoverErosionInwardsFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
public void Create_WithDikeProfiles_AddDikeProfileEntities()
{
// Setup
const string filePath = "some/path/to/my/dikeprofiles";
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.DikeProfiles.AddRange(new[]
{
DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id1"),
DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id2")
}, filePath);
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// Assert
Assert.AreEqual(2, entity.DikeProfileEntities.Count);
GrassCoverErosionInwardsFailureMechanismMetaEntity generalInputEntity =
entity.GrassCoverErosionInwardsFailureMechanismMetaEntities.Single();
TestHelper.AssertAreEqualButNotSame(filePath, generalInputEntity.DikeProfileCollectionSourcePath);
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(
failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
public void Create_WithCalculationGroup_ReturnFailureMechanismEntityWithCalculationGroupEntities(bool inAssembly)
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "A"
});
failureMechanism.CalculationsGroup.Children.Add(new CalculationGroup
{
Name = "B"
});
var registry = new PersistenceRegistry();
// Call
FailureMechanismEntity entity = failureMechanism.Create(registry);
// 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(2, childGroupEntities.Length);
Assert.AreEqual("A", childGroupEntities[0].Name);
Assert.AreEqual(0, childGroupEntities[0].Order);
Assert.AreEqual("B", childGroupEntities[1].Name);
Assert.AreEqual(1, childGroupEntities[1].Order);
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void ClearAllCalculationOutputAndHydraulicBoundaryLocations_WithVariousCalculations_ClearsHydraulicBoundaryLocationAndCalculationsAndReturnsAffectedObjects()
{
// Setup
GrassCoverErosionInwardsFailureMechanism failureMechanism = CreateFullyConfiguredFailureMechanism();
IEnumerable <GrassCoverErosionInwardsCalculation> grassCoverErosionInwardsCalculations =
failureMechanism.Calculations
.Cast <GrassCoverErosionInwardsCalculation>()
.ToArray();
IObservable[] expectedAffectedCalculations = grassCoverErosionInwardsCalculations.Where(c => c.HasOutput)
.Cast <IObservable>()
.ToArray();
IObservable[] expectedAffectedCalculationInputs = grassCoverErosionInwardsCalculations.Select(c => c.InputParameters)
.Where(i => i.HydraulicBoundaryLocation != null)
.Cast <IObservable>()
.ToArray();
// Call
IEnumerable <IObservable> affectedItems =
GrassCoverErosionInwardsDataSynchronizationService.ClearAllCalculationOutputAndHydraulicBoundaryLocations(failureMechanism);
// Assert
// Note: To make sure the clear is performed regardless of what is done with
// the return result, no ToArray() should be called before these assertions:
Assert.IsTrue(failureMechanism.Calculations.Cast <GrassCoverErosionInwardsCalculation>()
.All(c => c.InputParameters.HydraulicBoundaryLocation == null &&
!c.HasOutput));
CollectionAssert.AreEquivalent(expectedAffectedCalculations.Concat(expectedAffectedCalculationInputs),
affectedItems);
}
public void AssembleSection_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
AdoptableWithProfileProbabilityFailureMechanismSectionResult sectionResult = failureMechanism.SectionResults.Single();
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
calculator.ThrowExceptionOnCalculate = true;
// Call
void Call() => GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleSection(
sectionResult, failureMechanism, assessmentSection);
// Assert
var exception = Assert.Throws <AssemblyException>(Call);
Exception innerException = exception.InnerException;
Assert.IsInstanceOf <FailureMechanismSectionAssemblyCalculatorException>(innerException);
Assert.AreEqual(innerException.Message, exception.Message);
}
}
public void Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
InAssembly = random.NextBoolean(),
GeneralInput =
{
ApplyLengthEffectInSection = random.NextBoolean()
}
};
// Call
var properties = new GrassCoverErosionInwardsFailureMechanismProperties(failureMechanism);
// Assert
Assert.IsInstanceOf <GrassCoverErosionInwardsFailureMechanismPropertiesBase>(properties);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly);
GeneralGrassCoverErosionInwardsInput generalInput = failureMechanism.GeneralInput;
Assert.AreEqual(2, properties.N.NumberOfDecimalPlaces);
Assert.AreEqual(generalInput.N,
properties.N,
properties.N.GetAccuracy());
Assert.AreEqual(generalInput.ApplyLengthEffectInSection, properties.ApplyLengthEffectInSection);
}
public void AssembleFailureMechanism_WithInput_SetsInputOnCalculator()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, "APath");
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismSectionAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismSectionAssemblyCalculator;
FailureMechanismAssemblyCalculatorStub failureMechanismAssemblyCalculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
GrassCoverErosionInwardsFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreEqual(failureMechanism.GeneralInput.N, failureMechanismAssemblyCalculator.FailureMechanismN);
Assert.AreSame(calculator.FailureMechanismSectionAssemblyResultOutput.AssemblyResult, failureMechanismAssemblyCalculator.SectionAssemblyResultsInput.Single());
Assert.AreEqual(failureMechanism.GeneralInput.ApplyLengthEffectInSection, failureMechanismAssemblyCalculator.ApplyLengthEffect);
}
}
public void UpdateDikeProfilesWithImportedData_WithCurrentDikeProfilesAndImportedDataHasPartialOverlap_UpdatesTargetCollection()
{
// Setup
const string addedDikeProfileId = "ID A";
const string removedDikeProfileId = "ID B";
const string updatedDikeProfileId = "ID C";
const string commonName = "Just a name for dike profile";
DikeProfile dikeProfileToBeRemoved = DikeProfileTestFactory.CreateDikeProfile(commonName, removedDikeProfileId);
DikeProfile dikeProfileToBeUpdated = DikeProfileTestFactory.CreateDikeProfile(commonName, updatedDikeProfileId);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
DikeProfileCollection dikeProfiles = failureMechanism.DikeProfiles;
dikeProfiles.AddRange(new[]
{
dikeProfileToBeRemoved,
dikeProfileToBeUpdated
}, sourceFilePath);
DikeProfile dikeProfileToUpdateFrom = DeepCloneAndModify(dikeProfileToBeUpdated);
DikeProfile dikeProfileToBeAdded = DikeProfileTestFactory.CreateDikeProfile(commonName, addedDikeProfileId);
DikeProfile[] readDikeProfiles =
{
dikeProfileToBeAdded,
dikeProfileToUpdateFrom
};
var strategy = new GrassCoverErosionInwardsDikeProfileUpdateDataStrategy(failureMechanism);
// Call
IEnumerable <IObservable> affectedObjects = strategy.UpdateDikeProfilesWithImportedData(readDikeProfiles,
sourceFilePath);
// Assert
Assert.AreEqual(2, dikeProfiles.Count);
DikeProfile[] expectedDikeProfiles =
{
dikeProfileToBeAdded,
dikeProfileToBeUpdated
};
CollectionAssert.AreEqual(expectedDikeProfiles, dikeProfiles);
DikeProfile addedDikeProfile = dikeProfiles[0];
Assert.AreSame(dikeProfileToBeAdded, addedDikeProfile);
AssertDikeProfile(dikeProfileToBeAdded, addedDikeProfile);
DikeProfile updatedDikeProfile = dikeProfiles[1];
Assert.AreSame(dikeProfileToBeUpdated, updatedDikeProfile);
AssertDikeProfile(dikeProfileToUpdateFrom, updatedDikeProfile);
CollectionAssert.AreEquivalent(new IObservable[]
{
dikeProfileToBeUpdated,
dikeProfiles
}, affectedObjects);
}
public void CreateCalculationActivitiesForFailureMechanism_WithValidCalculations_ReturnsGrassCoverErosionInwardsCalculationActivitiesWithParametersSet()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(failureMechanism,
mocks,
validFilePath);
mocks.ReplayAll();
GrassCoverErosionInwardsCalculation calculation1 = CreateValidCalculation();
GrassCoverErosionInwardsCalculation calculation2 = CreateValidCalculation();
failureMechanism.CalculationsGroup.Children.AddRange(new[]
{
calculation1,
calculation2
});
// Call
IEnumerable <CalculatableActivity> activities = GrassCoverErosionInwardsCalculationActivityFactory.CreateCalculationActivities(
failureMechanism, assessmentSection);
// Assert
CollectionAssert.AllItemsAreInstancesOfType(activities, typeof(GrassCoverErosionInwardsCalculationActivity));
Assert.AreEqual(2, activities.Count());
HydraulicBoundaryDatabase hydraulicBoundaryDatabase = assessmentSection.HydraulicBoundaryDatabase;
AssertGrassCoverErosionInwardsCalculationActivity(activities.First(), calculation1, hydraulicBoundaryDatabase);
AssertGrassCoverErosionInwardsCalculationActivity(activities.ElementAt(1), calculation2, hydraulicBoundaryDatabase);
mocks.VerifyAll();
}
public void IsEnabled_DikeProfileCollectionSourcePathNull_ReturnFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var dikeProfiles = new DikeProfileCollection();
var context = new DikeProfilesContext(dikeProfiles, failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
mocks.VerifyAll();
}
public void Constructor_ExpectedValues()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
// Call
var properties = new GrassCoverErosionInwardsFailureMechanismProperties(
failureMechanism);
// Assert
Assert.IsInstanceOf <GrassCoverErosionInwardsFailureMechanismPropertiesBase>(properties);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
GeneralGrassCoverErosionInwardsInput generalInput = failureMechanism.GeneralInput;
Assert.AreEqual(generalInput.FbFactor.Mean, properties.FbFactor.Mean);
Assert.AreEqual(generalInput.FbFactor.StandardDeviation, properties.FbFactor.StandardDeviation);
Assert.AreEqual(generalInput.FnFactor.Mean, properties.FnFactor.Mean);
Assert.AreEqual(generalInput.FnFactor.StandardDeviation, properties.FnFactor.StandardDeviation);
Assert.AreEqual(generalInput.FrunupModelFactor.Mean, properties.FrunupModelFactor.Mean);
Assert.AreEqual(generalInput.FrunupModelFactor.StandardDeviation, properties.FrunupModelFactor.StandardDeviation);
Assert.AreEqual(generalInput.FshallowModelFactor.Mean, properties.FshallowModelFactor.Mean);
Assert.AreEqual(generalInput.FshallowModelFactor.StandardDeviation, properties.FshallowModelFactor.StandardDeviation);
}
public void CurrentPath_DikeProfileCollectionHasPathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
const string expectedFilePath = "some/path";
var surfaceLines = new DikeProfileCollection();
surfaceLines.AddRange(new[]
{
DikeProfileTestFactory.CreateDikeProfile()
}, expectedFilePath);
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
var context = new DikeProfilesContext(surfaceLines, failureMechanism, assessmentSection);
using (var plugin = new GrassCoverErosionInwardsPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(expectedFilePath, currentFilePath);
mocks.VerifyAll();
}
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
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
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 ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism
{
InAssembly = false
};
var context = new GrassCoverErosionInwardsFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(1, children.Length);
var comment = (Comment)children[0];
Assert.AreSame(failureMechanism.NotInAssemblyComments, comment);
mocks.VerifyAll();
}
public void ChildNodeObjects_Always_ReturnDikeProfiles()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
DikeProfile dikeProfile1 = DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id1");
DikeProfile dikeProfile2 = DikeProfileTestFactory.CreateDikeProfile(string.Empty, "id2");
var failureMechanism = new GrassCoverErosionInwardsFailureMechanism();
failureMechanism.DikeProfiles.AddRange(new[]
{
dikeProfile1,
dikeProfile2
}, "path");
var dikeProfilesContext = new DikeProfilesContext(failureMechanism.DikeProfiles, failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(dikeProfilesContext);
// Assert
Assert.AreEqual(2, children.Length);
Assert.AreSame(dikeProfile1, children.ElementAt(0));
Assert.AreSame(dikeProfile2, children.ElementAt(1));
mocks.VerifyAll();
}
