public void IsEnabled_FailureMechanismSectionsSourcePathSet_ReturnTrue()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new PipingStructureFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo importInfo = GetUpdateInfo(plugin);
// Call
bool isEnabled = importInfo.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
mocks.VerifyAll();
}
public void Create_StringPropertiesDoNotShareReference()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
InAssemblyInputComments =
{
Body = "Some input text"
},
InAssemblyOutputComments =
{
Body = "Some output text"
},
NotInAssemblyComments =
{
Body = "Really not in assembly"
}
};
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);
Assert.IsNull(entity.CalculationsInputComments);
}
public void AssembleFailureMechanism_CalculatorThrowsException_ThrowsAssemblyException()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
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() => PipingStructureFailureMechanismAssemblyFactory.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 Constructor_ExpectedValues()
{
// Setup
var random = new Random(21);
var failureMechanism = new PipingStructureFailureMechanism
{
InAssembly = random.NextBoolean()
};
// Call
var properties = new PipingStructureFailureMechanismProperties(failureMechanism);
// Assert
Assert.IsInstanceOf <ObjectProperties <PipingStructureFailureMechanism> >(properties);
Assert.AreEqual(failureMechanism.Name, properties.Name);
Assert.AreEqual(failureMechanism.Code, properties.Code);
Assert.AreEqual(failureMechanism.InAssembly, properties.InAssembly);
GeneralInput 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 PipingStructureFailureMechanism
{
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
PipingStructureFailureMechanismAssemblyFactory.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 CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism();
var assessmentSection = mocks.Stub <IAssessmentSection>();
assessmentSection.Stub(asm => asm.GetFailureMechanisms()).Return(new IFailureMechanism[]
{
failureMechanism
});
mocks.ReplayAll();
using (var view = new NonAdoptableFailureMechanismResultView <PipingStructureFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual)))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
mocks.VerifyAll();
}
public void CloseForData_ViewNotCorrespondingToRemovedFailureMechanismContext_ReturnsFalse()
{
// Setup
var failureMechanismContext = mocks.StrictMock <IFailureMechanismContext <IFailureMechanism> >();
failureMechanismContext.Expect(fm => fm.WrappedData).Return(new PipingStructureFailureMechanism());
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
using (var view = new NonAdoptableFailureMechanismResultView <PipingStructureFailureMechanism>(
failureMechanism.SectionResults, failureMechanism, assessmentSection,
(fm, ass) => new FailureMechanismAssemblyResultWrapper(double.NaN, AssemblyMethod.Manual)))
{
// Call
bool closeForData = info.CloseForData(view, failureMechanismContext);
// Assert
Assert.IsFalse(closeForData);
}
mocks.VerifyAll();
}
private FailureMechanismAssemblyResultRow CreatePipingStructureFailureMechanismAssemblyResultRow()
{
PipingStructureFailureMechanism pipingStructure = AssessmentSection.PipingStructure;
return(FailureMechanismAssemblyResultRowFactory.CreateRow(
pipingStructure, () => PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(pipingStructure, AssessmentSection)));
}
public void CurrentPath_FailureMechanismSectionsSourcePathSet_ReturnsExpectedPath()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
string sourcePath = TestHelper.GetScratchPadPath();
failureMechanism.SetSections(Enumerable.Empty <FailureMechanismSection>(), sourcePath);
var context = new PipingStructureFailureMechanismSectionsContext(failureMechanism, assessmentSection);
using (var plugin = new RiskeerPlugin())
{
UpdateInfo updateInfo = GetUpdateInfo(plugin);
// Call
string currentFilePath = updateInfo.CurrentPath(context);
// Assert
Assert.AreEqual(sourcePath, currentFilePath);
mocks.VerifyAll();
}
}
public void AssembleFailureMechanism_CalculatorRan_ReturnsExpectedOutput()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
AssemblyResult =
{
ProbabilityResultType = FailureMechanismAssemblyProbabilityResultType.Automatic
}
};
var assessmentSection = new AssessmentSectionStub();
using (new AssemblyToolCalculatorFactoryConfig())
{
var calculatorFactory = (TestAssemblyToolCalculatorFactory)AssemblyToolCalculatorFactory.Instance;
FailureMechanismAssemblyCalculatorStub calculator = calculatorFactory.LastCreatedFailureMechanismAssemblyCalculator;
// Call
FailureMechanismAssemblyResultWrapper result = PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, assessmentSection);
// Assert
Assert.AreSame(calculator.AssemblyResultOutput, result);
}
}
/// <summary>
/// Creates a <see cref="FailureMechanismEntity"/> based on the information of the <see cref="PipingStructureFailureMechanism"/>.
/// </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>
internal static FailureMechanismEntity Create(this PipingStructureFailureMechanism mechanism, PersistenceRegistry registry)
{
FailureMechanismEntity entity = mechanism.Create(FailureMechanismType.PipingAtStructure, registry);
AddEntitiesForSectionResults(mechanism.SectionResults, registry);
AddEntitiesForFailureMechanismMeta(mechanism, entity);
return(entity);
}
public void Constructor_InAssemblyTrue_PropertiesHaveExpectedAttributesValues()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
InAssembly = true
};
// Call
var properties = new PipingStructureFailureMechanismProperties(failureMechanism);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(5, dynamicProperties.Count);
const string generalCategory = "Algemeen";
const string lengthEffectCategory = "Lengte-effect";
PropertyDescriptor nameProperty = dynamicProperties[namePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty,
generalCategory,
"Naam",
"De naam van het faalmechanisme.",
true);
PropertyDescriptor labelProperty = dynamicProperties[codePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(labelProperty,
generalCategory,
"Label",
"Het label van het faalmechanisme.",
true);
PropertyDescriptor inAssemblyProperty = dynamicProperties[inAssemblyPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(inAssemblyProperty,
generalCategory,
"In assemblage",
"Geeft aan of dit faalmechanisme wordt meegenomen in de assemblage.",
true);
PropertyDescriptor nProperty = dynamicProperties[nPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nProperty,
lengthEffectCategory,
"N [-]",
"De parameter 'N' die gebruikt wordt om het lengte-effect mee te nemen in de beoordeling.");
PropertyDescriptor applySectionLengthInSectionProperty = dynamicProperties[applyLengthEffectInSectionPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(applySectionLengthInSectionProperty,
lengthEffectCategory,
"Toepassen lengte-effect binnen vak",
"Geeft aan of het lengte-effect binnen een vak toegepast wordt.",
true);
}
private static void AddEntitiesForFailureMechanismMeta(PipingStructureFailureMechanism failureMechanism,
FailureMechanismEntity entity)
{
var metaEntity = new PipingStructureFailureMechanismMetaEntity
{
N = failureMechanism.GeneralInput.N
};
entity.PipingStructureFailureMechanismMetaEntities.Add(metaEntity);
}
public void Create_WithoutSections_EmptyFailureMechanismSectionEntities()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism();
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
CollectionAssert.IsEmpty(entity.FailureMechanismSectionEntities);
Assert.IsNull(entity.FailureMechanismSectionCollectionSourcePath);
}
public void AssembleFailureMechanism_AssessmentSectionNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism();
// Call
void Call() => PipingStructureFailureMechanismAssemblyFactory.AssembleFailureMechanism(failureMechanism, null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("assessmentSection", exception.ParamName);
}
public void Create_PersistenceRegistryNull_ThrowsArgumentNullException()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism();
// Call
TestDelegate test = () => failureMechanism.Create(null);
// Assert
string paramName = Assert.Throws <ArgumentNullException>(test).ParamName;
Assert.AreEqual("registry", paramName);
}
public void Constructor_ExpectedValues()
{
// Call
var failureMechanism = new PipingStructureFailureMechanism();
// Assert
Assert.IsInstanceOf <FailureMechanismBase <NonAdoptableFailureMechanismSectionResult> >(failureMechanism);
Assert.IsInstanceOf <IHasGeneralInput>(failureMechanism);
Assert.AreEqual("Piping bij kunstwerk", failureMechanism.Name);
Assert.AreEqual("PKW", failureMechanism.Code);
Assert.IsFalse(failureMechanism.GeneralInput.ApplyLengthEffectInSection);
CollectionAssert.IsEmpty(failureMechanism.Sections);
CollectionAssert.IsEmpty(failureMechanism.SectionResults);
}
public void ForeColor_Always_ReturnsControlText()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var context = new PipingStructureFailureMechanismContext(failureMechanism, assessmentSection);
// Call
Color textColor = info.ForeColor(context);
// Assert
Assert.AreEqual(Color.FromKnownColor(KnownColor.ControlText), textColor);
}
public void CloseForData_ViewCorrespondingToRemovedAssessmentSection_ReturnsTrue()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new PipingStructureFailureMechanism();
using (StandAloneFailureMechanismView <PipingStructureFailureMechanism, NonAdoptableFailureMechanismSectionResult> view =
CreateView(failureMechanism, assessmentSection))
{
// Call
bool closeForData = info.CloseForData(view, assessmentSection);
// Assert
Assert.IsTrue(closeForData);
}
}
public void Text_Always_ReturnsName()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var failureMechanismContext = new PipingStructureFailureMechanismContext(failureMechanism, assessmentSection);
// Call
string text = info.Text(failureMechanismContext);
// Assert
Assert.AreEqual(failureMechanism.Name, text);
}
public void GetViewName_WithFailureMechanismContext_ReturnsNameOfFailureMechanism()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var failureMechanismContext = new PipingStructureFailureMechanismContext(failureMechanism, assessmentSection);
// Call
string viewName = info.GetViewName(null, failureMechanismContext);
// Assert
Assert.AreEqual(failureMechanism.Name, viewName);
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
// Call
var context = new PipingStructureFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionResultContext <NonAdoptableFailureMechanismSectionResult> >(context);
mocks.VerifyAll();
}
public void CreateInstance_WithContext_ReturnsView()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var context = new PipingStructureFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Call
IView view = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <NonAdoptableFailureMechanismResultView <PipingStructureFailureMechanism> >(view);
mocks.VerifyAll();
}
public void GetViewData_WithContext_ReturnsWrappedFailureMechanismResult()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var context = new PipingStructureFailureMechanismSectionResultContext(
failureMechanism.SectionResults, failureMechanism, assessmentSection);
// Call
object viewData = info.GetViewData(context);
// Assert
Assert.AreSame(failureMechanism.SectionResults, viewData);
mocks.VerifyAll();
}
public void ChildNodeObjects_FailureMechanismInAssemblyTrue_ReturnChildDataNodes()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new PipingStructureFailureMechanism();
var failureMechanismContext = new PipingStructureFailureMechanismContext(failureMechanism, assessmentSection);
// Call
object[] children = info.ChildNodeObjects(failureMechanismContext).ToArray();
// Assert
Assert.AreEqual(2, children.Length);
var inputFolder = (CategoryTreeFolder)children[0];
Assert.AreEqual(2, inputFolder.Contents.Count());
Assert.AreEqual("Invoer", inputFolder.Name);
Assert.AreEqual(TreeFolderCategory.Input, inputFolder.Category);
var failureMechanismSectionsContext = (PipingStructureFailureMechanismSectionsContext)inputFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismSectionsContext.WrappedData);
Assert.AreSame(assessmentSection, failureMechanismSectionsContext.AssessmentSection);
var inAssemblyInputComments = (Comment)inputFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.InAssemblyInputComments, inAssemblyInputComments);
var outputFolder = (CategoryTreeFolder)children[1];
Assert.AreEqual(2, outputFolder.Contents.Count());
Assert.AreEqual("Oordeel", outputFolder.Name);
Assert.AreEqual(TreeFolderCategory.Output, outputFolder.Category);
var failureMechanismResultsContext = (PipingStructureFailureMechanismSectionResultContext)
outputFolder.Contents.ElementAt(0);
Assert.AreSame(failureMechanism, failureMechanismResultsContext.FailureMechanism);
Assert.AreSame(failureMechanism.SectionResults, failureMechanismResultsContext.WrappedData);
var inAssemblyOutputComments = (Comment)outputFolder.Contents.ElementAt(1);
Assert.AreSame(failureMechanism.InAssemblyOutputComments, inAssemblyOutputComments);
}
public void CreateInstance_WithContext_NewPropertiesWithFailureMechanismAsData()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
var context = new PipingStructureFailureMechanismContext(failureMechanism, assessmentSection);
// Call
IObjectProperties objectProperties = info.CreateInstance(context);
// Assert
Assert.IsInstanceOf <PipingStructureFailureMechanismProperties>(objectProperties);
Assert.AreSame(failureMechanism, objectProperties.Data);
mocks.VerifyAll();
}
public void DynamicVisibleValidationMethod_DependingOnInAssembly_ReturnExpectedVisibility(bool inAssembly)
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
InAssembly = inAssembly
};
var properties = new PipingStructureFailureMechanismProperties(failureMechanism);
// Call & Assert
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Name)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.Code)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(nameof(properties.InAssembly)));
Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.N)));
Assert.AreEqual(inAssembly, properties.DynamicVisibleValidationMethod(nameof(properties.ApplyLengthEffectInSection)));
Assert.IsTrue(properties.DynamicVisibleValidationMethod(null));
}
public void Constructor_ExpectedValues()
{
// Setup
var mocks = new MockRepository();
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var failureMechanism = new PipingStructureFailureMechanism();
// Call
var context = new PipingStructureFailureMechanismSectionsContext(failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismSectionsContext>(context);
Assert.AreSame(failureMechanism, context.WrappedData);
Assert.AreSame(assessmentSection, context.AssessmentSection);
mocks.VerifyAll();
}
public void Constructor_InAssemblyFalse_PropertiesHaveExpectedAttributesValues()
{
// Setup
var failureMechanism = new PipingStructureFailureMechanism
{
InAssembly = false
};
// Call
var properties = new PipingStructureFailureMechanismProperties(failureMechanism);
// Assert
PropertyDescriptorCollection dynamicProperties = PropertiesTestHelper.GetAllVisiblePropertyDescriptors(properties);
Assert.AreEqual(3, dynamicProperties.Count);
const string generalCategory = "Algemeen";
PropertyDescriptor nameProperty = dynamicProperties[namePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(nameProperty,
generalCategory,
"Naam",
"De naam van het faalmechanisme.",
true);
PropertyDescriptor labelProperty = dynamicProperties[codePropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(labelProperty,
generalCategory,
"Label",
"Het label van het faalmechanisme.",
true);
PropertyDescriptor inAssemblyProperty = dynamicProperties[inAssemblyPropertyIndex];
PropertiesTestHelper.AssertRequiredPropertyDescriptorProperties(inAssemblyProperty,
generalCategory,
"In assemblage",
"Geeft aan of dit faalmechanisme wordt meegenomen in de assemblage.",
true);
}
public void Create_WithSections_FailureMechanismSectionEntitiesCreated()
{
// Setup
const string filePath = "failureMechanismSections/File/Path";
var failureMechanism = new PipingStructureFailureMechanism();
failureMechanism.SetSections(new[]
{
FailureMechanismSectionTestFactory.CreateFailureMechanismSection()
}, filePath);
// Call
FailureMechanismEntity entity = failureMechanism.Create(new PersistenceRegistry());
// Assert
Assert.AreEqual(1, entity.FailureMechanismSectionEntities.Count);
Assert.AreEqual(1, entity.FailureMechanismSectionEntities
.SelectMany(fms => fms.NonAdoptableFailureMechanismSectionResultEntities)
.Count());
}
