public void AddNewArgLineViaCommandTest(TestLanguage language)
{
var openSolutionSuccess = OpenSolutionWithName(language, "DefaultProject");
Assert.That(openSolutionSuccess, Is.True);
var package = (CmdArgsPackage)Utils.LoadPackage(new Guid(CmdArgsPackage.PackageGuidString));
ICommand addCommand = package?.ToolWindowViewModel?.AddEntryCommand;
Assert.That(addCommand, Is.Not.Null);
InvokeInUIThread(() =>
{
Assert.That(package.ToolWindowViewModel.AddEntryCommand.CanExecute(null), Is.True);
addCommand.Execute(null);
});
var argItems = package?.ToolWindowViewModel?.CurrentArgumentList?.DataCollection;
Assert.That(argItems, Is.Not.Null);
Assert.That(argItems, Has.Count.EqualTo(1));
var argItem = argItems[0];
Assert.That(argItem, Has.Property("Id").Not.EqualTo(Guid.Empty));
Assert.That(argItem, Has.Property("Command").EqualTo(""));
}
private static Declarations ExecuteGetDeclarations(string lineText, IScanner scanner, IServiceProvider site)
{
// Create the authoring scope.
ParseRequest request = new ParseRequest(false);
request.Reason = ParseReason.DisplayMemberList;
AuthoringScope scope = ConsoleAuthoringScope.CreateScope(request);
Assert.IsNotNull(scope);
// Create a mock IConsoleText
BaseMock mockConsoleText = MockFactories.ConsoleTextFactory.GetInstance();
mockConsoleText.AddMethodReturnValues(
string.Format("{0}.{1}", typeof(IConsoleText).FullName, "TextOfLine"),
new object[] { lineText });
ConsoleAuthoringScope.PythonConsole = mockConsoleText as IConsoleText;
// Create a language service.
TestLanguage language = new TestLanguage();
// Set the scanner for this language.
language.MockScanner = scanner;
ConsoleAuthoringScope.Language = language;
// Set the site for the scope.
ConsoleAuthoringScope.Site = site;
// Create the view and token info to call the scope.
IVsTextView view = MockFactories.TextViewFactory.GetInstance() as IVsTextView;
TokenInfo tokenInfo = new TokenInfo();
return(scope.GetDeclarations(view, 0, 0, tokenInfo, ParseReason.DisplayMemberList));
}
public void SaveCommandsToJsonTest(TestLanguage language)
{
OpenSolutionWithName(language, "DefaultProject");
LoadExtension();
var curList = ExtensionPackage?.ToolWindowViewModel?.CurrentArgumentList;
Assert.IsNotNull(curList);
var initalCommands = new[] { "arg1", "Arg2", "arg 3" };
InvokeInUIThread(() =>
{
foreach (var initalCommand in initalCommands)
{
curList.AddNewItem(initalCommand);
}
});
Utils.ForceSaveSolution();
string jsonFile = JsonFileFromProjectIndex(1);
CheckJsonFile(jsonFile, initalCommands);
}
public void AvoidEmptyJsonFileTest(TestLanguage language)
{
OpenSolutionWithName(language, "DefaultProject");
LoadExtension();
Utils.ForceSaveSolution();
Assert.IsFalse(File.Exists(JsonFileFromProjectIndex(1)));
}
public void SaveAndLoadSuoTest(TestLanguage language)
{
var package = (CmdArgsPackage)Utils.LoadPackage(new Guid(CmdArgsPackage.PackageGuidString));
var openSolutionSuccess = OpenSolutionWithName(language, "DefaultProject");
Assert.That(openSolutionSuccess, Is.True);
var properties = (CmdArgsOptionPage)package.GetDialogPage(typeof(CmdArgsOptionPage));
properties.VcsSupport = false;
var curList = package?.ToolWindowViewModel?.CurrentArgumentList;
Assert.IsNotNull(curList);
var initalCommands = new[] { "arg1", "Arg2", "arg 3" };
var initalEnabledStates = new[] { true, true, false };
InvokeInUIThread(() =>
{
for (int i = 0; i < initalCommands.Length; i++)
{
curList.AddNewItem(initalCommands[i], initalEnabledStates[i]);
}
});
Utils.ForceSaveSolution();
var solutionFile = Dte.Solution.FullName;
Assert.IsTrue(File.Exists(solutionFile));
Dte.Solution.Close();
Assert.IsNull(package.ToolWindowViewModel.CurrentArgumentList);
OpenSolutionWithPath(solutionFile);
var curDataList = package?.ToolWindowViewModel?.CurrentArgumentList?.DataCollection;
Assert.IsNotNull(curDataList);
Assert.AreEqual(initalCommands.Length, curDataList.Count);
for (int i = 0; i < initalCommands.Length; i++)
{
var curItem = curDataList[i];
Assert.AreEqual(initalCommands[i], curItem.Command);
Assert.AreEqual(initalEnabledStates[i], curItem.Enabled);
Assert.AreNotEqual(Guid.Empty, curItem.Id);
}
}
public void CollectArgsDistinctFromExistingProjectConfigsTest(TestLanguage language)
{
var openSolutionSuccess = OpenSolutionWithName(language, "CollectArgsDistinctTest");
Assert.That(openSolutionSuccess, Is.True);
var package = (CmdArgsPackage)Utils.LoadPackage(new Guid(CmdArgsPackage.PackageGuidString));
var argItems = package?.ToolWindowViewModel?.CurrentArgumentList?.DataCollection;
Assert.That(argItems, Is.Not.Null);
Assert.That(argItems, Has.Count.EqualTo(1));
var argItem = argItems[0];
Assert.That(argItem, Has.Property("Id").Not.EqualTo(Guid.Empty));
Assert.That(argItem, Has.Property("Command").EqualTo("same args in every config"));
}
protected bool OpenSolutionWithName(TestLanguage language, string solutionName, bool overrideExistingTemp = true)
{
var langFolder = TranslateLanguageFolderName(language);
var path = Path.GetFullPath(Path.Combine(BaseTestSolutionPath, langFolder, solutionName));
Assert.IsTrue(Directory.Exists(path), $"No Solution folder at path: {path}");
if (overrideExistingTemp)
{
if (Directory.Exists(solutionName))
{
Directory.Delete(solutionName, true);
}
Helper.DirectoryCopy(path, solutionName);
}
return(OpenSolutionWithPath(Path.GetFullPath(Path.Combine(solutionName, "Solution.sln"))));
}
public void LoadCommandsFromCreatedJsonTest(TestLanguage language)
{
OpenSolutionWithName(language, "DefaultProject");
var jsonFile = JsonFileFromProjectIndex(1);
LoadExtension();
File.WriteAllText(jsonFile, @"
{
""DataCollection"": [
{
""Id"": ""ac3f6619-4027-4417-935c-824c3a45e604"",
""Command"": ""Imported Args""
},
{
""Id"": ""2a47c412-f43d-45f7-b248-6aa8cf233c30"",
""Command"": ""second imported arg""
},
{
""Command"": ""imported arg without id""
}
]
}");
System.Threading.Thread.Sleep(1000);
var currentList = ExtensionPackage?.ToolWindowViewModel?.CurrentArgumentList?.DataCollection;
Assert.IsNotNull(currentList);
Assert.AreEqual(3, currentList.Count);
var arg1 = currentList[0];
Assert.AreEqual("Imported Args", arg1.Command);
Assert.AreEqual(new Guid("ac3f6619-4027-4417-935c-824c3a45e604"), arg1.Id);
var arg2 = currentList[1];
Assert.AreEqual("second imported arg", arg2.Command);
Assert.AreEqual(new Guid("2a47c412-f43d-45f7-b248-6aa8cf233c30"), arg2.Id);
var arg3 = currentList[2];
Assert.AreEqual("imported arg without id", arg3.Command);
Assert.AreNotEqual(Guid.Empty, arg3.Id);
}
private string TranslateLanguageFolderName(TestLanguage lang)
{
switch (lang)
{
case TestLanguage.CSharpDotNetFW: return("C#_.NetFW");
case TestLanguage.CSharpDotNetCore: return("C#_.NetCore");
case TestLanguage.CPP: return("C++");
case TestLanguage.VBDotNetFW: return("VB_.NetFW");
case TestLanguage.NodeJS: return("Node.js");
case TestLanguage.FSharpDotNetFW: return("F#_.NetFW");
default: throw new ArgumentException("Unknown TestLanguage");
}
}
public void DisabledVcsSupportTest(TestLanguage language)
{
OpenSolutionWithName(language, "DefaultProject");
LoadExtension();
SetVcsSupport(false);
InvokeInUIThread(() =>
{
var currentList = ExtensionPackage?.ToolWindowViewModel?.CurrentArgumentList;
Assert.IsNotNull(currentList);
currentList.AddNewItem("TestItem1");
currentList.AddNewItem("TestItem2");
});
Utils.ForceSaveSolution();
Assert.IsFalse(File.Exists(JsonFileFromProjectIndex(1)));
}
public void CollectArgsFromExistingProjectConfigsTest(TestLanguage language)
{
var openSolutionSuccess = OpenSolutionWithName(language, "CollectArgsTest");
Assert.That(openSolutionSuccess, Is.True);
var package = (CmdArgsPackage)Utils.LoadPackage(new Guid(CmdArgsPackage.PackageGuidString));
var argItems = package?.ToolWindowViewModel?.CurrentArgumentList?.DataCollection;
Assert.That(argItems, Is.Not.Null);
if (language == TestLanguage.NodeJS)
{
Assert.That(argItems.Select(item => item.Command).Distinct().Count(), Is.EqualTo(1));
}
else
{
Assert.That(argItems.Select(item => item.Command).Distinct().Count(), Is.GreaterThan(1));
}
Assert.That(argItems, Has.All.Property("Command").StartWith("args for "));
Assert.That(argItems, Has.All.Property("Id").Not.EqualTo(Guid.Empty));
}
/// <summary>
/// Takes a data directory, traverses the entire subdirectory structure,
/// extracts full file paths as expected file paths,
/// converts expected file paths into actual output file paths as well for a later diff.
/// </summary>
/// <param name="dataDirectory">Data directory full path</param>
/// <param name="testDataDirectoryName">test data directory name, e.g. TestDataCSharp</param>
/// <param name="outputDirectoryName">output directory name, e.g. OutputDirectoryCSharp</param>
/// <returns></returns>
private static IEnumerable <(string, string)> GetFilePaths(TestLanguage language, string dataDirectory, string testDataDirectoryName, string outputDirectoryName)
{
HashSet <string> extensions = new HashSet <string>();
switch (language)
{
case TestLanguage.CSharp:
extensions.Add(".cs");
break;
case TestLanguage.Java:
extensions.Add(".java");
break;
case TestLanguage.TypeScript:
extensions.Add(".ts");
break;
case TestLanguage.PHP:
extensions.Add(".php");
break;
case TestLanguage.ObjC:
extensions.Add(".m");
extensions.Add(".h");
break;
default:
throw new ArgumentException("unexpected test language", nameof(language));
}
return(from file in new DirectoryInfo(dataDirectory)
.EnumerateFiles("*", SearchOption.AllDirectories)
.Where(f => extensions.Contains(f.Extension))
let actualOutputFilePath = file.FullName.Replace(testDataDirectoryName, outputDirectoryName)
let expectedFilePath = file.FullName
select(expectedFilePath, actualOutputFilePath));
}
public void SetCommandLineArgsViaDebug(TestLanguage language)
{
OpenSolutionWithName(language, "ReadCmdArgsProject");
LoadExtension();
var args = new List <(string Arg, bool Enabled)>
{
("Arg1", true),
("Arg42", false),
("Arg2", true),
};
var curList = ExtensionPackage.ToolWindowViewModel.CurrentArgumentList;
InvokeInUIThread(() =>
{
foreach (var arg in args)
{
curList.AddNewItem(arg.Arg, arg.Enabled);
}
});
Dte.Solution.SolutionBuild.Build(true);
using (var waiter = new WaitUntil())
{
Dte.Events.DebuggerEvents.OnEnterDesignMode += reason => waiter.Finish();
Dte.ExecuteCommand("Debug.Start");
}
Assert.That(File.Exists("ReadCmdArgsProject/CmdLineArgs.txt"), Is.True);
var cmdArgsFile = File.ReadAllText("ReadCmdArgsProject/CmdLineArgs.txt");
var cmdArgsTest = string.Join(" ", args.Where(arg => arg.Enabled).Select(arg => arg.Arg));
Assert.That(cmdArgsFile, Is.EqualTo(cmdArgsTest));
}
public LanguagesAgnostic(TestLanguage language)
{
Language = language;
}
private static Declarations ExecuteGetDeclarations(string lineText, IScanner scanner, IServiceProvider site)
{
// Create the authoring scope.
ParseRequest request = new ParseRequest(false);
request.Reason = ParseReason.DisplayMemberList;
AuthoringScope scope = ConsoleAuthoringScope.CreateScope(request);
Assert.IsNotNull(scope);
// Create a mock IConsoleText
BaseMock mockConsoleText = MockFactories.ConsoleTextFactory.GetInstance();
mockConsoleText.AddMethodReturnValues(
string.Format("{0}.{1}", typeof(IConsoleText).FullName, "TextOfLine"),
new object[] { lineText });
ConsoleAuthoringScope.PythonConsole = mockConsoleText as IConsoleText;
// Create a language service.
TestLanguage language = new TestLanguage();
// Set the scanner for this language.
language.MockScanner = scanner;
ConsoleAuthoringScope.Language = language;
// Set the site for the scope.
ConsoleAuthoringScope.Site = site;
// Create the view and token info to call the scope.
IVsTextView view = MockFactories.TextViewFactory.GetInstance() as IVsTextView;
TokenInfo tokenInfo = new TokenInfo();
return scope.GetDeclarations(view, 0, 0, tokenInfo, ParseReason.DisplayMemberList);
}
public void SetCommandLineArgsViaResart(TestLanguage language)
{
OpenSolutionWithName(language, "ReadCmdArgsProject");
LoadExtension();
switch (language)
{
case TestLanguage.CSharpDotNetFW:
Assert.True(SetBreakpoint("Program.cs", 14));
break;
case TestLanguage.CSharpDotNetCore:
Assert.True(SetBreakpoint("Program.cs", 10));
break;
case TestLanguage.CPP:
Assert.True(SetBreakpoint("Project1.cpp", 10));
break;
case TestLanguage.VBDotNetFW:
Assert.True(SetBreakpoint("Module1.vb", 3));
break;
case TestLanguage.NodeJS:
Assert.True(SetBreakpoint("app.ts", 9));
break;
case TestLanguage.FSharpDotNetFW:
Assert.True(SetBreakpoint("Program.fs", 6));
break;
default:
throw new ArgumentOutOfRangeException(nameof(language), language, null);
}
bool SetBreakpoint(string fileName, int line, int column = 1)
{
ProjectItem codeFile = Dte.Solution.FindProjectItem(fileName);
if (codeFile == null)
{
return(false);
}
Dte.Debugger.Breakpoints.Add("", codeFile.FileNames[0], line, column);
return(true);
}
using (var waiter = new WaitUntil())
{
Dte.Events.DebuggerEvents.OnEnterBreakMode +=
(dbgEventReason reason, ref dbgExecutionAction action) => waiter.Finish();
Dte.Debugger.Go();
}
var args = new List <(string Arg, bool Enabled)>
{
("Arg1", true),
("Arg42", false),
("Arg2", true),
};
var curList = ExtensionPackage.ToolWindowViewModel.CurrentArgumentList;
InvokeInUIThread(() =>
{
foreach (var arg in args)
{
curList.AddNewItem(arg.Arg, arg.Enabled);
}
});
Dte.Debugger.Breakpoints.Item(1).Enabled = false;
using (var waiter = new WaitUntil())
{
int dbgDesignEnters = 0;
Dte.Events.DebuggerEvents.OnEnterDesignMode += reason =>
{
dbgDesignEnters++;
if (dbgDesignEnters == 2)
{
waiter.Finish();
}
};
Dte.ExecuteCommand("Debug.Restart");
}
Assert.That(File.Exists("ReadCmdArgsProject/CmdLineArgs.txt"), Is.True);
var cmdArgsFile = File.ReadAllText("ReadCmdArgsProject/CmdLineArgs.txt");
var cmdArgsTest = string.Join(" ", args.Where(arg => arg.Enabled).Select(arg => arg.Arg));
Assert.That(cmdArgsFile, Is.EqualTo(cmdArgsTest));
}
public static void Run(TestLanguage language, bool isBeta = false)
{
string getMetadataFile(TestLanguage testLanguage)
{
switch (testLanguage)
{
case TestLanguage.CSharp:
case TestLanguage.Java:
return(MetadataMultipleNamespacesFile);
case TestLanguage.TypeScript:
case TestLanguage.PHP:
case TestLanguage.ObjC:
return(MetadataWithSubNamespacesFile);
default:
throw new ArgumentException("unexpected test language", nameof(testLanguage));
}
}
// Arrange
var languageStr = language.ToString();
var directoryPostfix = languageStr + (isBeta ? "Beta" : string.Empty);
var outputDirectoryName = OutputDirectoryPrefix + directoryPostfix;
var testDataDirectoryName = TestDataDirectoryPrefix + directoryPostfix;
var currentDirectory = Path.GetDirectoryName(typeof(MultipleNamespacesTestRunner).Assembly.Location); //Directory.GetCurrentDirectory();
var outputDirectory = Path.Combine(currentDirectory, outputDirectoryName);
var dataDirectory = Path.Combine(currentDirectory, testDataDirectoryName);
var metadataFile = Path.Combine(currentDirectory, MetadataDirectoryName, getMetadataFile(language));
var csdlContents = MetadataResolver.GetMetadata(metadataFile);
var options = new Options
{
Verbosity = VerbosityLevel.Info,
Output = outputDirectory,
GenerationMode = GenerationMode.Files,
Language = languageStr
};
if (language == TestLanguage.Java)
{
options.EndpointVersion = "v1.0"; // fixes java generation test as the endpoint contains the version and the default options are not applied in this testing mode
}
if (isBeta)
{
if (TestLanguage.PHP == language)
{
options.Properties = new List <string> {
"php.namespacePrefix:Beta"
};
}
if (TestLanguage.TypeScript == language)
{
options.Properties = new List <string> {
"typescript.namespacePostfix:beta"
};
}
}
// Act
if (Directory.Exists(outputDirectory))
{
Directory.Delete(outputDirectory, recursive: true); // clean up any previous runs
}
Generator.GenerateFiles(csdlContents, options);
// Assert
var testOutputBuilder = new StringBuilder();
var errorCounter = 0;
foreach (var(expectedFilePath, actualOutputFilePath) in GetFilePaths(language, dataDirectory, testDataDirectoryName, outputDirectoryName))
{
if (File.Exists(actualOutputFilePath))
{
CompareFiles(testOutputBuilder, expectedFilePath, actualOutputFilePath, ref errorCounter);
}
else
{
testOutputBuilder.AppendLine();
testOutputBuilder.AppendLine($"{++errorCounter}. Output file is not generated: {actualOutputFilePath}");
}
}
if (errorCounter > 0)
{
string message = string.Join(Environment.NewLine,
"A diff between following folders are strongly encouraged to see if the changes are intended:",
dataDirectory,
outputDirectory,
string.Empty,
$"If the changes are expected, please replace the contents of {testDataDirectoryName} with the contents of {outputDirectoryName}.",
string.Empty,
"Details of failures:");
Assert.Fail(message + testOutputBuilder.ToString());
}
}
public void File()
{
TestOutput output = new();
ModelTransferObject model = new()
{
Name = "Test1",
Language = new TestLanguage(this.resolver)
};
transferObjects.Add(model);
this.writer.Write(string.Empty);
Assert.AreEqual(1, output.Files.Count, "Unexpected number of files");
Assert.AreEqual("Test1", output.Files[0].Name, "Unexpected file name");
}
// [TestMethod]
// public void Namespace()
// {
// TestConfiguration configuration = new();
// List<ModelTransferObject> transferObjects = new();
// ModelTransferObject model = new()
// {
// Namespace = "KY.Test",
// Language = new TestLanguage()
// };
// transferObjects.Add(model);
// List<FileTemplate> files = this.writer.Write(configuration, transferObjects);
// Assert.AreEqual(1, files[0].Namespaces.Count, "Unexpected number of namespace");
// Assert.AreEqual("KY.Test", files[0].Namespaces[0].Name, "Unexpected namespace");
// }
//
// [TestMethod]
// public void ClassName()
// {
// TestConfiguration configuration = new();
// List<ModelTransferObject> transferObjects = new();
// ModelTransferObject model = new()
// {
// Name = "Test1",
// Language = new TestLanguage()
// };
// transferObjects.Add(model);
// List<FileTemplate> files = this.writer.Write(configuration, transferObjects);
// Assert.AreEqual("Test1", files[0].Namespaces[0].Children[0].Name, "Unexpected class name");
// }
//
// [TestMethod]
// public void OneField()
// {
// TestConfiguration configuration = new();
// List<ModelTransferObject> transferObjects = new();
// ModelTransferObject model = new()
// {
// Name = "Test1",
// Namespace = "KY.Test",
// Language = new TestLanguage()
// };
// model.Fields.Add(new FieldTransferObject { Name = "Field1", Type = new TypeTransferObject { Name = "string" } });
// transferObjects.Add(model);
// List<FileTemplate> files = this.writer.Write(configuration, transferObjects);
// ClassTemplate classTemplate = (ClassTemplate)files[0].Namespaces[0].Children[0];
// Assert.AreEqual(1, classTemplate.Fields.Count, "Unexpected number of fields");
// Assert.AreEqual("Field1", classTemplate.Fields[0].Name, "Unexpected field name");
// Assert.AreEqual("string", classTemplate.Fields[0].Type.Name, "Unexpected field type");
// Assert.AreEqual(0, classTemplate.Properties.Count, "Unexpected number of properties");
// }
//
// [TestMethod]
// public void OneProperty()
// {
// TestConfiguration configuration = new();
// List<ModelTransferObject> transferObjects = new();
// ModelTransferObject model = new()
// {
// Name = "Test1",
// Namespace = "KY.Test",
// Language = new TestLanguage()
// };
// model.Properties.Add(new PropertyTransferObject { Name = "Prop1", Type = new TypeTransferObject { Name = "string" } });
// transferObjects.Add(model);
// List<FileTemplate> files = this.writer.Write(configuration, transferObjects);
// ClassTemplate classTemplate = (ClassTemplate)files[0].Namespaces[0].Children[0];
// Assert.AreEqual(1, classTemplate.Properties.Count, "Unexpected number of properties");
// Assert.AreEqual("Prop1", classTemplate.Properties[0].Name, "Unexpected property name");
// Assert.AreEqual("string", classTemplate.Properties[0].Type.Name, "Unexpected property type");
// Assert.AreEqual(0, classTemplate.Fields.Count, "Unexpected number of fields");
// }
//
// [TestMethod]
// public void OnePropertyWithDifferentNamespace()
// {
// TestConfiguration configuration = new();
// List<ModelTransferObject> transferObjects = new();
// ModelTransferObject model = new()
// {
// Name = "Test1",
// Namespace = "KY.Test",
// Language = new TestLanguage()
// };
// model.Properties.Add(new PropertyTransferObject { Name = "Prop1", Type = new TypeTransferObject { Name = "Test2", Namespace = "KY.Test.Different" } });
// transferObjects.Add(model);
// List<FileTemplate> files = this.writer.Write(configuration, transferObjects);
// ClassTemplate classTemplate = (ClassTemplate)files[0].Namespaces[0].Children[0];
// Assert.AreEqual(1, classTemplate.Properties.Count, "Unexpected number of properties");
// Assert.AreEqual("Prop1", classTemplate.Properties[0].Name, "Unexpected property name");
// Assert.AreEqual("Test2", classTemplate.Properties[0].Type.Name, "Unexpected property type");
// Assert.AreEqual(1, classTemplate.Usings.Count, "Unexpected number of usings");
// Assert.AreEqual("KY.Test.Different", classTemplate.Usings[0].Namespace, "Unexpected property namespace");
// Assert.AreEqual(0, classTemplate.Fields.Count, "Unexpected number of fields");
// }
}
