public void ContextMenuStrip_FailureMechanismHasCalculationsWithOutput_ContextMenuItemClearAllOutputEnabledAndToolTipSet()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var pipingCalculation = new TestPipingCalculationScenario(true);
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem clearOutputItem = contextMenu.Items[contextMenuClearIndex];
Assert.IsTrue(clearOutputItem.Enabled);
Assert.AreEqual("Wis de uitvoer van alle berekeningen binnen dit faalmechanisme.", clearOutputItem.ToolTipText);
}
}
}
public void ContextMenuStrip_FailureMechanismHasNoCalculationsWithOutput_ContextMenuItemsClearOutputAndClearIllustrationPointsDisabledAndToolTipSet()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new TestPipingCalculationScenario());
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
ToolStripItem clearOutputItem = contextMenu.Items[contextMenuClearIndex];
Assert.IsFalse(clearOutputItem.Enabled);
Assert.AreEqual("Er zijn geen berekeningen met uitvoer om te wissen.", clearOutputItem.ToolTipText);
ToolStripItem clearIllustrationPointsItem = contextMenu.Items[contextMenuClearIllustrationPointsIndex];
Assert.IsFalse(clearOutputItem.Enabled);
Assert.AreEqual("Er zijn geen berekeningen met illustratiepunten om te wissen.", clearIllustrationPointsItem.ToolTipText);
}
}
}
public void ChildNodeObjects_FailureMechanismInAssemblyFalse_ReturnChildDataNodes()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism
{
InAssembly = false
};
var context = new PipingFailureMechanismContext(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 CloseForData_NestedViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculation = new ProbabilisticPipingCalculationScenario();
var calculationGroup = new CalculationGroup();
calculationGroup.Children.Add(calculation);
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(calculationGroup);
var context = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection);
using (var view = new PipingInputView
{
Data = calculation
})
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsFalse(closeForData);
mocks.VerifyAll();
}
}
public void GivenFailureMechanismWithCalculationOfUnsupportedType_WhenCalculatingAllFromContextMenu_ThenThrowsNotSupportedException()
{
// Given
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new TestPipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(new TestPipingCalculationScenario());
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var mainWindow = mocks.Stub <IMainWindow>();
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(g => g.MainWindow).Return(mainWindow);
mocks.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// When
void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Then
Assert.Throws <NotSupportedException>(Call);
}
}
}
public void ChildNodeObjects_FailureMechanismInAssemblyTrue_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var inputsFolder = (CategoryTreeFolder)children[0];
Assert.AreEqual("Invoer", inputsFolder.Name);
Assert.AreEqual(TreeFolderCategory.Input, inputsFolder.Category);
Assert.AreEqual(2, inputsFolder.Contents.Count());
var failureMechanismSectionsContext = (FailureMechanismSectionsContext)inputsFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismSectionsContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismSectionsContext.AssessmentSection);
var comment = (Comment)inputsFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.InAssemblyInputComments, comment);
var outputsFolder = (CategoryTreeFolder)children[1];
Assert.AreEqual("Oordeel", outputsFolder.Name);
Assert.AreEqual(TreeFolderCategory.Output, outputsFolder.Category);
Assert.AreEqual(3, outputsFolder.Contents.Count());
var failureMechanismScenariosContext = (PipingScenariosContext)outputsFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismScenariosContext.FailureMechanism);
Assert.AreSame(failureMechanism.CalculationsGroup, failureMechanismScenariosContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismScenariosContext.AssessmentSection);
var failureMechanismResultsContext = (PipingFailureMechanismSectionResultContext)outputsFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism, failureMechanismResultsContext.FailureMechanism);
Assert.AreSame(failureMechanism.SectionResults, failureMechanismResultsContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismResultsContext.AssessmentSection);
var commentContext = (Comment)outputsFolder.Contents.ElementAt(2);
Assert.AreSame(failureMechanism.InAssemblyOutputComments, commentContext);
}
public void Text_WithContext_ReturnsName()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var context = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection);
// Call
string text = info.Text(context);
// Assert
Assert.AreEqual("Piping", text);
}
public void CreateInstance_WithContext_ReturnPipingFailureMechanismView()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Call
var view = (PipingFailureMechanismView)info.CreateInstance(context);
// Assert
Assert.AreSame(failureMechanism, view.FailureMechanism);
Assert.AreSame(assessmentSection, view.AssessmentSection);
}
public void ChildNodeObjects_WithContext_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var pipingFailureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(pipingFailureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(context).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var inputsFolder = (CategoryTreeFolder)children[0];
Assert.AreEqual("Invoer", inputsFolder.Name);
Assert.AreEqual(TreeFolderCategory.Input, inputsFolder.Category);
Assert.AreEqual(4, inputsFolder.Contents.Count());
var failureMechanismSectionsContext = (FailureMechanismSectionsContext)inputsFolder.Contents.ElementAt(0);
Assert.AreSame(pipingFailureMechanism, failureMechanismSectionsContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismSectionsContext.AssessmentSection);
var surfaceLinesContext = (PipingSurfaceLinesContext)inputsFolder.Contents.ElementAt(1);
Assert.AreSame(pipingFailureMechanism.SurfaceLines, surfaceLinesContext.WrappedData);
Assert.AreSame(pipingFailureMechanism, surfaceLinesContext.FailureMechanism);
Assert.AreSame(assessmentSection, surfaceLinesContext.AssessmentSection);
var stochasticSoilModelContext = (PipingStochasticSoilModelCollectionContext)inputsFolder.Contents.ElementAt(2);
Assert.AreSame(pipingFailureMechanism, stochasticSoilModelContext.FailureMechanism);
Assert.AreSame(pipingFailureMechanism, stochasticSoilModelContext.FailureMechanism);
Assert.AreSame(assessmentSection, stochasticSoilModelContext.AssessmentSection);
var calculationsInputComments = (Comment)inputsFolder.Contents.ElementAt(3);
Assert.AreSame(pipingFailureMechanism.CalculationsInputComments, calculationsInputComments);
var calculationsFolder = (PipingCalculationGroupContext)children[1];
Assert.AreSame(pipingFailureMechanism.CalculationsGroup, calculationsFolder.WrappedData);
Assert.IsNull(calculationsFolder.Parent);
Assert.AreSame(pipingFailureMechanism.SurfaceLines, calculationsFolder.AvailablePipingSurfaceLines);
Assert.AreSame(pipingFailureMechanism.StochasticSoilModels, calculationsFolder.AvailableStochasticSoilModels);
Assert.AreSame(pipingFailureMechanism, calculationsFolder.FailureMechanism);
}
public void GetViewName_WithPipingFailureMechanismContext_ReturnsNameOfFailureMechanism()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Call
string viewName = info.GetViewName(null, context);
// Assert
Assert.AreEqual(failureMechanism.Name, viewName);
mocks.VerifyAll();
}
public void ContextMenuStrip_AllRequiredInputSet_ContextMenuItemCalculateAllAndValidateAllEnabled()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new TestPipingFailureMechanism
{
CalculationsGroup =
{
Children =
{
new TestPipingCalculationScenario()
}
}
};
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuCalculateAllIndex,
"Alles be&rekenen",
"Voer alle berekeningen binnen dit faalmechanisme uit.",
RiskeerCommonFormsResources.CalculateAllIcon);
TestHelper.AssertContextMenuStripContainsItem(contextMenu, contextMenuValidateAllIndex,
"Alles &valideren",
"Valideer alle berekeningen binnen dit faalmechanisme.",
RiskeerCommonFormsResources.ValidateAllIcon);
}
}
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
// Call
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismContext <PipingFailureMechanism> >(context);
Assert.AreSame(assessmentSection, context.Parent);
Assert.AreSame(failureMechanism, context.WrappedData);
mocks.VerifyAll();
}
public void CreateInstance_WithContext_NewPropertiesWithFailureMechanismAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <PipingFailureMechanismProperties>(objectProperties);
Assert.AreSame(failureMechanism, objectProperties.Data);
mocks.VerifyAll();
}
public void ContextMenuStrip_WithContext_CallsContextMenuBuilderMethods()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var pipingFailureMechanism = new PipingFailureMechanism();
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(pipingFailureMechanism, assessmentSection);
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddOpenItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(context, null, treeViewControl);
}
// Assert
// Assert expectancies are called in TearDown()
}
public void CloseForData_ViewCorrespondingToRemovedFailureMechanismContext_ReturnsTrue()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
using (var view = new PipingFailureMechanismResultView(failureMechanism.SectionResults, failureMechanism, assessmentSection))
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism();
var context = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection);
using (var view = new PipingScenariosView(failureMechanism.CalculationsGroup, failureMechanism, assessmentSection))
{
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
public void AdditionalDataCheck_Always_ReturnTrueOnlyIfFailureMechanismInAssembly(bool inAssembly)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingFailureMechanism
{
InAssembly = inAssembly
};
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
// Call
bool result = info.AdditionalDataCheck(context);
// Assert
Assert.AreEqual(inAssembly, result);
mocks.VerifyAll();
}
public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(a => a.HydraulicBoundaryDatabase).Return(new HydraulicBoundaryDatabase());
mocks.ReplayAll();
using (var view = new PipingCalculationsView(new CalculationGroup(), new PipingFailureMechanism(), assessmentSection))
{
var context = new PipingFailureMechanismContext(new PipingFailureMechanism(), assessmentSection);
// Call
bool closeForData = info.CloseForData(view, context);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
public void ContextMenuStrip_FailureMechanismInAssemblyFalse_CallsContextMenuBuilderMethods()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
using (var treeViewControl = new TreeViewControl())
{
var failureMechanism = new PipingFailureMechanism
{
InAssembly = false
};
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = mocks.StrictMock <IContextMenuBuilder>();
using (mocks.Ordered())
{
menuBuilder.Expect(mb => mb.AddCustomItem(null)).IgnoreArguments().Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddCollapseAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddExpandAllItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddSeparator()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.AddPropertiesItem()).Return(menuBuilder);
menuBuilder.Expect(mb => mb.Build()).Return(null);
}
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
mocks.ReplayAll();
plugin.Gui = gui;
// Call
info.ContextMenuStrip(context, null, treeViewControl);
}
// Assert
mocks.VerifyAll();
}
public void GivenMultiplePipingCalculationsWithOutput_WhenClearingOutputFromContextMenu_ThenPipingOutputCleared(bool confirm)
{
// Given
using (var treeViewControl = new TreeViewControl())
{
var pipingCalculation1 = new TestPipingCalculationScenario(true);
var pipingCalculation2 = new TestPipingCalculationScenario(true);
var observer = mocks.StrictMock <IObserver>();
if (confirm)
{
observer.Expect(o => o.UpdateObserver()).Repeat.Twice();
}
var failureMechanism = new PipingFailureMechanism();
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation1);
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation2);
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation1);
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation2);
failureMechanism.CalculationsGroup.Children.ElementAt(0).Attach(observer);
failureMechanism.CalculationsGroup.Children.ElementAt(1).Attach(observer);
string messageBoxTitle = null, messageBoxText = null;
DialogBoxHandler = (name, wnd) =>
{
var messageBox = new MessageBoxTester(wnd);
messageBoxText = messageBox.Text;
messageBoxTitle = messageBox.Title;
if (confirm)
{
messageBox.ClickOk();
}
else
{
messageBox.ClickCancel();
}
};
using (ContextMenuStrip contextMenuStrip = info.ContextMenuStrip(context, null, treeViewControl))
{
// When
contextMenuStrip.Items[contextMenuClearIndex].PerformClick();
// Then
foreach (ICalculation calc in failureMechanism.CalculationsGroup.Children.OfType <ICalculation>())
{
Assert.AreNotEqual(confirm, calc.HasOutput);
}
Assert.AreEqual("Bevestigen", messageBoxTitle);
Assert.AreEqual("Weet u zeker dat u alle uitvoer wilt wissen?", messageBoxText);
}
}
}
public void ContextMenuStrip_FailureMechanismHasCalculationWithOutput_ReturnsContextMenuWithCommonItems()
{
// Setup
var failureMechanism = new TestPipingFailureMechanism();
var pipingCalculation = new TestPipingCalculationScenario(true);
failureMechanism.CalculationsGroup.Children.Add(pipingCalculation);
var assessmentSection = mocks.Stub <IAssessmentSection>();
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var applicationFeatureCommandHandler = mocks.Stub <IApplicationFeatureCommands>();
var importCommandHandler = mocks.Stub <IImportCommandHandler>();
var exportCommandHandler = mocks.Stub <IExportCommandHandler>();
var updateCommandHandler = mocks.Stub <IUpdateCommandHandler>();
var viewCommandsHandler = mocks.Stub <IViewCommands>();
using (var treeViewControl = new TreeViewControl())
{
var menuBuilder = new ContextMenuBuilder(applicationFeatureCommandHandler,
importCommandHandler,
exportCommandHandler,
updateCommandHandler,
viewCommandsHandler,
context,
treeViewControl);
var gui = mocks.Stub <IGui>();
gui.Stub(cmp => cmp.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
// Call
using (ContextMenuStrip menu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Assert
Assert.AreEqual(12, menu.Items.Count);
TestHelper.AssertContextMenuStripContainsItem(menu,
0,
"&Openen",
"Open de gegevens in een nieuw documentvenster.",
CoreGuiResources.OpenIcon,
false);
TestHelper.AssertContextMenuStripContainsItem(menu,
2,
"Alles &valideren",
"Valideer alle berekeningen binnen dit faalmechanisme.",
RiskeerCommonFormsResources.ValidateAllIcon);
TestHelper.AssertContextMenuStripContainsItem(menu,
3,
"Alles be&rekenen",
"Voer alle berekeningen binnen dit faalmechanisme uit.",
RiskeerCommonFormsResources.CalculateAllIcon);
TestHelper.AssertContextMenuStripContainsItem(menu,
5,
"&Wis alle uitvoer...",
"Wis de uitvoer van alle berekeningen binnen dit faalmechanisme.",
RiskeerCommonFormsResources.ClearIcon);
TestHelper.AssertContextMenuStripContainsItem(menu,
6,
"Wis alle illustratiepunten...",
"Er zijn geen berekeningen met illustratiepunten om te wissen.",
RiskeerCommonFormsResources.ClearIllustrationPointsIcon,
false);
TestHelper.AssertContextMenuStripContainsItem(menu,
8,
"Alles i&nklappen",
"Klap dit element en alle onderliggende elementen in.",
CoreGuiResources.CollapseAllIcon,
false);
TestHelper.AssertContextMenuStripContainsItem(menu,
9,
"Alles ui&tklappen",
"Klap dit element en alle onderliggende elementen uit.",
CoreGuiResources.ExpandAllIcon,
false);
TestHelper.AssertContextMenuStripContainsItem(menu,
11,
"Ei&genschappen",
"Toon de eigenschappen in het Eigenschappenpaneel.",
CoreGuiResources.PropertiesHS,
false);
CollectionAssert.AllItemsAreInstancesOfType(new[]
{
menu.Items[1],
menu.Items[4],
menu.Items[7],
menu.Items[10]
}, typeof(ToolStripSeparator));
}
}
}
public void ContextMenuStrip_ClickOnCalculateAllItem_ScheduleAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var calculationA =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationB =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationC =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var calculationD =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
calculationA.Name = "A";
calculationB.Name = "B";
calculationC.Name = "C";
calculationD.Name = "D";
failureMechanism.CalculationsGroup.Children.Add(calculationA);
failureMechanism.CalculationsGroup.Children.Add(calculationC);
failureMechanism.CalculationsGroup.Children.Add(calculationB);
failureMechanism.CalculationsGroup.Children.Add(calculationD);
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
IMainWindow mainWindow = MainWindowTestHelper.CreateMainWindowStub(mocks);
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.MainWindow).Return(mainWindow);
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
var calculatorFactory = mocks.Stub <IHydraRingCalculatorFactory>();
calculatorFactory.Stub(cf => cf.CreatePipingCalculator(null))
.IgnoreArguments()
.Return(new TestPipingCalculator());
mocks.ReplayAll();
plugin.Gui = gui;
DialogBoxHandler = (name, wnd) =>
{
// Expect an activity dialog which is automatically closed
};
using (new PipingSubCalculatorFactoryConfig())
using (new HydraRingCalculatorFactoryConfig(calculatorFactory))
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuCalculateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(28, msgs.Length);
Assert.AreEqual("Uitvoeren van berekening 'A' is gestart.", msgs[0]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[2]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[3]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[4]);
Assert.AreEqual("Uitvoeren van berekening 'A' is gelukt.", msgs[5]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gestart.", msgs[6]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[7]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[9]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[12]);
Assert.AreEqual("Uitvoeren van berekening 'C' is gelukt.", msgs[13]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gestart.", msgs[14]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[15]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[16]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[17]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[18]);
Assert.AreEqual("Uitvoeren van berekening 'B' is gelukt.", msgs[19]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gestart.", msgs[20]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[21]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[22]);
CalculationServiceTestHelper.AssertCalculationStartMessage(msgs[23]);
CalculationServiceTestHelper.AssertCalculationEndMessage(msgs[26]);
Assert.AreEqual("Uitvoeren van berekening 'D' is gelukt.", msgs[27]);
});
}
}
}
public void ContextMenuStrip_ClickOnValidateAllItem_ValidateAllChildCalculations()
{
// Setup
using (var treeViewControl = new TreeViewControl())
{
var assessmentSection = new AssessmentSectionStub();
var hydraulicBoundaryLocation = new TestHydraulicBoundaryLocation();
TestPipingFailureMechanism failureMechanism = TestPipingFailureMechanism.GetFailureMechanismWithSurfaceLinesAndStochasticSoilModels();
assessmentSection.HydraulicBoundaryDatabase.FilePath = validHydraulicBoundaryDatabaseFilePath;
HydraulicBoundaryDatabaseTestHelper.SetHydraulicBoundaryLocationConfigurationSettings(assessmentSection.HydraulicBoundaryDatabase);
assessmentSection.SetHydraulicBoundaryLocationCalculations(new[]
{
hydraulicBoundaryLocation
}, true);
var validSemiProbabilisticCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <SemiProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var invalidSemiProbabilisticCalculation =
SemiProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <SemiProbabilisticPipingCalculationScenario>();
var validProbabilisticCalculation =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithValidInput <ProbabilisticPipingCalculationScenario>(
hydraulicBoundaryLocation);
var invalidProbabilisticCalculation =
ProbabilisticPipingCalculationTestFactory.CreateCalculationWithInvalidInput <ProbabilisticPipingCalculationScenario>();
failureMechanism.CalculationsGroup.Children.Add(validSemiProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(invalidProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(validProbabilisticCalculation);
failureMechanism.CalculationsGroup.Children.Add(invalidSemiProbabilisticCalculation);
var context = new PipingFailureMechanismContext(failureMechanism, assessmentSection);
var menuBuilder = new CustomItemsOnlyContextMenuBuilder();
var gui = mocks.Stub <IGui>();
gui.Stub(g => g.Get(context, treeViewControl)).Return(menuBuilder);
gui.Stub(cmp => cmp.MainWindow).Return(mocks.Stub <IMainWindow>());
mocks.ReplayAll();
plugin.Gui = gui;
using (ContextMenuStrip contextMenu = info.ContextMenuStrip(context, null, treeViewControl))
{
// Call
void Call() => contextMenu.Items[contextMenuValidateAllIndex].PerformClick();
// Assert
TestHelper.AssertLogMessages(Call, messages =>
{
string[] msgs = messages.ToArray();
Assert.AreEqual(18, msgs.Length);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[0]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[1]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[2]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[8]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[9]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[10]);
CalculationServiceTestHelper.AssertValidationStartMessage(msgs[11]);
CalculationServiceTestHelper.AssertValidationEndMessage(msgs[17]);
});
}
}
}
