public bool Export()
{
if (!AreSpecificFailureMechanismsUniquelyNamed())
{
log.Error(Resources.AssemblyExporter_Specific_failure_mechanisms_must_have_a_unique_name);
return(false);
}
ExportableAssessmentSection exportableAssessmentSection = CreateExportableAssessmentSection();
if (exportableAssessmentSection == null)
{
log.Error(Resources.AssemblyExporter_No_AssemblyResult_exported_Check_results_for_details);
return(false);
}
try
{
SerializableAssemblyWriter.WriteAssembly(SerializableAssemblyCreator.Create(exportableAssessmentSection),
filePath);
}
catch (AssemblyCreatorException)
{
log.Error(Resources.AssemblyExporter_No_AssemblyResult_exported_Check_results_for_details);
return(false);
}
catch (CriticalFileWriteException e)
{
log.ErrorFormat(Resources.AssemblyExporter_Error_Exception_0_no_AssemblyResult_exported, e.Message);
return(false);
}
return(true);
}
public void WriteAssembly_FullyConfiguredAssembly_ReturnsExpectedFile()
{
// Setup
string folderPath = TestHelper.GetScratchPadPath(nameof(WriteAssembly_FullyConfiguredAssembly_ReturnsExpectedFile));
Directory.CreateDirectory(folderPath);
string filePath = Path.Combine(folderPath, "actualAssembly.gml");
SerializableAssembly assembly = CreateSerializableAssembly();
try
{
// Call
SerializableAssemblyWriter.WriteAssembly(assembly, filePath);
// Assert
Assert.IsTrue(File.Exists(filePath));
string pathToExpectedFile = Path.Combine(testDataPath, "configuredAssembly.gml");
string expectedXml = File.ReadAllText(pathToExpectedFile);
string actualXml = File.ReadAllText(filePath);
Assert.AreEqual(expectedXml, actualXml);
}
finally
{
DirectoryHelper.TryDelete(folderPath);
}
}
public void WriteAssembly_FilePathNull_ThrowsArgumentNullException()
{
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), null);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("filePath", exception.ParamName);
}
public void WriteAssembly_SerializableAssemblyNull_ThrowsArgumentNullException()
{
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(null, string.Empty);
// Assert
var exception = Assert.Throws <ArgumentNullException>(Call);
Assert.AreEqual("serializableAssembly", exception.ParamName);
}
public void WriteAssembly_FilePathInvalid_ThrowsCriticalFileWriteException(string filePath)
{
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath);
// Assert
var exception = Assert.Throws <CriticalFileWriteException>(Call);
Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message);
Assert.IsInstanceOf <ArgumentException>(exception.InnerException);
}
public void WriteAssembly_FileInUse_ThrowsCriticalFileWriteException()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(WriteAssembly_FileInUse_ThrowsCriticalFileWriteException));
using (var fileDisposeHelper = new FileDisposeHelper(filePath))
{
fileDisposeHelper.LockFiles();
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath);
// Assert
var exception = Assert.Throws <CriticalFileWriteException>(Call);
Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message);
Assert.IsInstanceOf <IOException>(exception.InnerException);
}
}
public void WriteAssembly_InvalidDirectoryRights_ThrowsCriticalFileWriteException()
{
// Setup
const string directoryName = nameof(WriteAssembly_InvalidDirectoryRights_ThrowsCriticalFileWriteException);
string directoryPath = TestHelper.GetScratchPadPath(directoryName);
using (var disposeHelper = new DirectoryDisposeHelper(TestHelper.GetScratchPadPath(), directoryName))
{
string filePath = Path.Combine(directoryPath, "test.bnd");
disposeHelper.LockDirectory(FileSystemRights.Write);
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(new SerializableAssembly(), filePath);
// Assert
var exception = Assert.Throws <CriticalFileWriteException>(Call);
Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message);
Assert.IsInstanceOf <UnauthorizedAccessException>(exception.InnerException);
}
}
public void WriteAssembly_ValidData_ValidFile()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(WriteAssembly_ValidData_ValidFile));
SerializableAssembly assembly = CreateSerializableAssembly();
try
{
// Call
SerializableAssemblyWriter.WriteAssembly(assembly, filePath);
// Assert
Assert.IsTrue(File.Exists(filePath));
string fileContent = File.ReadAllText(filePath);
Assert.AreEqual(GetSerializedAssembly(assembly), fileContent);
}
finally
{
File.Delete(filePath);
}
}
public void GivenFullyConfiguredAssembly_WhenWrittenToFile_ThenValidFileCreated()
{
// Given
SerializableAssembly assembly = CreateSerializableAssembly();
string filePath = TestHelper.GetScratchPadPath(nameof(GivenFullyConfiguredAssembly_WhenWrittenToFile_ThenValidFileCreated));
try
{
// When
SerializableAssemblyWriter.WriteAssembly(assembly, filePath);
// Then
Assert.IsTrue(File.Exists(filePath));
string fileContent = File.ReadAllText(filePath);
Console.WriteLine(fileContent);
var schema = new XmlSchemaSet();
schema.Add("http://localhost/standaarden/assemblage", Path.Combine(testDataPath, "assemblage.xsd"));
XDocument doc = XDocument.Parse(fileContent);
var msg = string.Empty;
doc.Validate(schema, (o, e) =>
{
msg += e.Message + Environment.NewLine;
});
if (msg == string.Empty)
{
Assert.Pass("Serialized document is valid" + Environment.NewLine);
}
else
{
Assert.Fail("Serialized document is invalid:" + Environment.NewLine + msg);
}
}
finally
{
File.Delete(filePath);
}
}
public void WriteAssembly_InvalidData_ThrowsCriticalFileWriteException()
{
// Setup
string filePath = TestHelper.GetScratchPadPath(nameof(WriteAssembly_InvalidData_ThrowsCriticalFileWriteException));
var assembly = new SerializableAssembly(
"id",
new Point2D(0.0, 10.0),
new Point2D(10.0, 20.0),
new SerializableAssessmentSection(),
new SerializableAssessmentProcess(),
new SerializableTotalAssemblyResult(),
new[]
{
new SerializableFailureMechanism()
},
Enumerable.Empty <SerializableFailureMechanismSectionAssembly>(),
Enumerable.Empty <SerializableCombinedFailureMechanismSectionAssembly>(),
Enumerable.Empty <SerializableFailureMechanismSectionCollection>(),
Enumerable.Empty <SerializableFailureMechanismSection>());
try
{
// Call
void Call() => SerializableAssemblyWriter.WriteAssembly(assembly, filePath);
// Assert
var exception = Assert.Throws <CriticalFileWriteException>(Call);
Assert.AreEqual($"Er is een onverwachte fout opgetreden tijdens het schrijven van het bestand '{filePath}'.", exception.Message);
Assert.IsInstanceOf <InvalidOperationException>(exception.InnerException);
}
finally
{
File.Delete(filePath);
}
}
