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"); // } }