public void The_Load_Method_Reads_One_File()
{
IProjectDeserialiser loader = new ProjectDeserialiserV1(fileController);
loader.LoadStaticFilenames("Folder");
fileController.AssertWasCalled(f => f.ReadAllText(Arg<string>.Is.Equal("Folder\\StaticFiles.xml")));
}
public void The_Load_Method_Reads_One_File()
{
IProjectDeserialiser loader = new ProjectDeserialiserV1(fileController);
loader.LoadApiExtensionFiles("Folder");
fileController.AssertWasCalled(f => f.ReadAllText(Arg<string>.Is.Equal("Folder\\Specs_For_Project_Loading__ApiExtensions.ApiExtensionTest.apiext.xml")));
}
public void The_Load_Method_Loads_Namespaces_Correctly()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
IDesignerProject project = MockRepository.GenerateMock<IDesignerProject>();
deserialiser.ReadProject(ExpectedXml.GetXmlDocRoot(), project, "Folder\\Project.aad");
project.AssertWasCalled(p => p.AddNamespace(Arg<string>.Is.Equal("Ns1")));
}
public void The_Load_Method_Gets_The_Correct_Filenames()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
var files = deserialiser.ReadStaticFilesDetails(ExpectedXml.GetXmlDocRoot());
Assert.That(files.Count(), Is.EqualTo(1));
Assert.That(files.ElementAt(0).FullFilePath, Is.EqualTo("static.dat"));
Assert.That(files.ElementAt(0).DisplayName, Is.EqualTo("static.dat"));
}
public virtual OutputFolder Read(XmlNode rootElement)
{
if (rootElement == null)
{
throw new DeserialisationException("Could not find Option element");
}
ProjectDeserialiserV1.CheckVersion(rootElement);
return(ReadFolder(rootElement.SelectSingleNode("Folder")));
}
public void The_Load_Method_Creates_The_Correct_UserOption()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
var options = deserialiser.ReadApiExtensions(ExpectedXml.GetXmlDocRoot());
Assert.That(options.Count(), Is.EqualTo(1), "Should only load one ApiExtension");
var option = options.ElementAt(0);
Assert.That(option.HasOverride, Is.True);
Assert.That(option.ExtendedMethod.DeclaringType.Name, Is.EqualTo("ApiExtensionTest"));
Assert.That(option.ExtendedMethod.Name, Is.EqualTo("Method1"));
Assert.That(option.OverridingFunctionBody, Is.EqualTo("return \"<>\";"));
}
public void The_Load_Method_Loads_ReferencedFiles_Correctly()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
IDesignerProject project = new ProjectBase(); //MockRepository.GenerateStub<IDesignerProject>();
deserialiser.ReadProject(ExpectedXml.GetXmlDocRoot(), project, "Folder\\Project.aad");
Assert.That(project.References, Has.Count(1));
Assert.That(project.References[0].FileName, Is.EqualTo("Folder\\file.dll"));
Assert.That(project.References[0].MergeWithAssembly, Is.True);
Assert.That(project.References[0].UseInWorkbench, Is.True);
}
public void The_Categories_Are_Loaded_Properly()
{
UserOption[] userOptions = new[]
{
new UserOption {VariableName = "var"},
new UserOption {VariableName = "Var2"}
};
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
deserialiser.ReadUserOptionDetails(userOptions, expectedXml.GetXmlDocRoot());
Assert.That(userOptions[0].Category, Is.EqualTo("Gen"), "The UserOption category was not loaded.");
Assert.That(userOptions[1].Category, Is.EqualTo("General"), "The default UserOption category is wrong.");
}
public void The_Load_Method_Creates_The_Correct_Project()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
IDesignerProject project = MockRepository.GenerateMock<IDesignerProject>();
deserialiser.ReadProject(ExpectedXml.GetXmlDocRoot(), project, "Folder\\Project.aad");
project.AssertWasCalled(p => p.ProjectName = "Test");
project.AssertWasCalled(p => p.ProjectDescription = "Desc");
project.AssertWasCalled(p => p.CompileFolderName = "Folder\\temp-compile"); // This should be the absolute path.
project.AssertWasCalled(p => p.Version = "1.2.3.2.1");
project.AssertWasCalled(p => p.ProjType = ProjectTypes.None);
project.AssertWasCalled(p => p.DebugProjectFile = "Folder\\debug.wbproj"); // Absolute path
project.AssertWasCalled(p => p.TestGenerateDirectory = "Folder\\test gen"); // Absolute path
}
public void The_Load_Method_Throws_An_Exception()
{
IProjectDeserialiser deserialiser = new ProjectDeserialiserV1(fileController);
deserialiser.LoadProjectFile("ProjectFile.aad", null);
}
/// <summary>
/// Open project file.
/// </summary>
/// <param name="filePath"></param>
public void Open(string filePath)
{
ProjectFileName = filePath;
if (Path.GetExtension(filePath) == ".stz")
{
ProjectLoadAndSaveHelper.ReadFromXml(this, filePath);
}
else
{
ProjectDeserialiserV1 deserialiserV1 = new ProjectDeserialiserV1(new FileController());
deserialiserV1.LoadProject(filePath, this);
foreach (var provider in ReferencedAssemblies.Where(ProviderInfo.IsProvider))
{
var resourceName = provider.GetName().Name + ".FunctionInfo.xml";
if (provider.GetManifestResourceInfo(resourceName) != null)
{
using (Stream funcInfo = provider.GetManifestResourceStream(resourceName))
if (funcInfo != null)
using (StreamReader reader = new StreamReader(funcInfo))
{
XmlDocument doc = new XmlDocument();
var xml = reader.ReadToEnd();
doc.LoadXml(xml);
deserialiserV1.LoadDefaultApiFunctionBodies(doc.DocumentElement, this);
}
}
}
}
IsDirty = false;
TriggerProjectChangedEvent(false);
}
public void The_Load_Method_Creates_Nothing()
{
IProjectDeserialiser loader = new ProjectDeserialiserV1(fileController);
IEnumerable<UserOption> optionFiles = loader.LoadUserOptionFiles("Folder");
Assert.That(optionFiles, Is.Empty);
}
public void The_Values_Are_Loaded_Properly()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
var option = deserialiser.ReadUserOption(expectedXml.GetXmlDocRoot());
Assert.That(option.Values, Has.Count(1));
Assert.That(option.Values[0], Is.EqualTo("val1"));
}
public void The_Load_Method_Creates_Nothing()
{
IProjectDeserialiser loader = new ProjectDeserialiserV1(fileController);
IEnumerable<ApiExtensionMethod> apiExtensionMethods = loader.LoadApiExtensionFiles("Folder");
Assert.That(apiExtensionMethods, Is.Empty);
}
public OutputsParserV1(ProjectDeserialiserV1 deserialiser)
{
Deserialiser = deserialiser;
}
public void The_Load_Details_Method_Creates_Nothing()
{
IProjectDeserialiser loader = new ProjectDeserialiserV1(fileController);
loader.LoadStaticFilenames("Folder");
fileController.AssertWasCalled(f => f.ReadAllText("Folder\\UserOptions.xml"));
}
public void The_Load_Method_Creates_The_Correct_UserOption()
{
ProjectDeserialiserV1 deserialiser = new ProjectDeserialiserV1(fileController);
var option = deserialiser.ReadUserOption(expectedXml.GetXmlDocRoot());
Assert.That(option.VariableName, Is.EqualTo("var"));
Assert.That(option.VarType, Is.EqualTo(typeof(string)));
Assert.That(option.Text, Is.EqualTo("test-text"));
Assert.That(option.Description, Is.EqualTo("test-description"));
Assert.That(option.Category, Is.EqualTo(""), "No category should be loaded at this level, see LoadUserOptionsDetails");
Assert.That(option.DefaultValueFunctionBody, Is.EqualTo("dv-body"));
Assert.That(option.IteratorType, Is.EqualTo(typeof(bool)));
Assert.That(option.ValidatorFunctionBody, Is.EqualTo("validator body"));
Assert.That(option.DisplayToUserFunctionBody, Is.EqualTo("return true;"));
Assert.That(option.ResetPerSession, Is.True);
}
public OutputsParserV1(ProjectDeserialiserV1 deserialiser)
{
Deserialiser = deserialiser;
}
public void The_Load_Method_Throws_An_Exception()
{
IProjectDeserialiser deserialiser = new ProjectDeserialiserV1(fileController);
deserialiser.LoadStaticFilenames("Folder");
}
public void InitFromDesignerProjectXml(XmlDocument doc)
{
log.DebugFormat("Loading Designer Project Info from Xml Document");
if (doc.DocumentElement == null)
throw new DeserialisationException("Could not load designer project info - xml document is empty");
if (doc.DocumentElement.Name == "ROOT")
{
LoadOldDesignerProjectXml(doc);
return;
}
// New loading code
ProjectBase designerProject = new ProjectBase();
ProjectDeserialiserV1 deserialiserV1 = new ProjectDeserialiserV1(new FileController());
deserialiserV1.LoadFromSingleXmlFile(designerProject, doc, ProjectFile);
TemplateName = designerProject.ProjectName;
TemplateDescription = designerProject.ProjectDescription;
// Providers and referenced files
ProvidersToBeDisplayed.Clear();
foreach (var referencedFile in designerProject.References)
{
if (referencedFile.IsProvider && referencedFile.UseInWorkbench)
{
ProvidersToBeDisplayed.Add(Path.GetFileName(referencedFile.FileName));
}
string pathsSearched = "";
string currentPath = Path.GetFileName(referencedFile.FileName);
bool assemblyFound = false;
foreach (string searchPath in SharedData.AssemblySearchPaths)
{
pathsSearched += searchPath + Environment.NewLine;
string filePath = Path.Combine(searchPath, currentPath);
if (File.Exists(filePath))
{
log.DebugFormat("Loading Provider from {0}", filePath);
assemblyFound = true;
ReferencedAssemblyPaths.Add(filePath);
break;
}
}
if (!assemblyFound)
{
if (MessageBox.Show(string.Format("'{0}' can't be located. The following folders have been searched: \n\n{1}\nDo you want to locate this file?", currentPath, pathsSearched), "File not found - Loading Project", MessageBoxButtons.YesNo, MessageBoxIcon.Exclamation) == DialogResult.Yes)
{
OpenFileDialog openFileDialog = new OpenFileDialog();
openFileDialog.FileName = currentPath;
if (openFileDialog.ShowDialog() == DialogResult.OK)
{
if (File.Exists(openFileDialog.FileName))
{
// Add this path to the search paths, because related assemblies might be in here as well.
SharedData.AddAssemblySearchPath(Path.GetDirectoryName(openFileDialog.FileName));
ReferencedAssemblyPaths.Add(openFileDialog.FileName);
assemblyFound = true;
}
}
}
if (!assemblyFound)
{
throw new FileNotFoundException(string.Format("Referenced assembly not found: {0}\n\nPlease make sure the assembly exists in one of these folders:{1}", currentPath, pathsSearched));
}
}
}
// User Options
var options = designerProject.UserOptions.Select(uo => uo.ToOption());
_Options.AddRange(options);
log.DebugFormat("Loaded up {0} UserOptions", _Options.Count);
_Options.ForEach(o => log.DebugFormat("UserOption {0} | On Type {1}", o.VariableName, o.IteratorName));
LoadReferencedAssemblies();
LoadAndFillProviders();
CombinedOutput = designerProject.RootOutput.ToCombinedOutput();
// I am not handling Default Value Functions. I think they no longer exist.
FillVirtualProperties();
}
