adding threading=0 plus the ability to pass random args.

Author: jsinglet

src/CodeQLToolkit.Features.Test/Commands/BaseExecuteUnitTestsCommandTarget.cs

@@ -14,6 +14,7 @@ public abstract class BaseExecuteUnitTestsCommandTarget : CommandTarget
         public string RunnerOS { get; set; }
         public string CLIVersion { get; set; }
         public string STDLibIdent { get; set; }
+        public string ExtraCodeQLArgs { get; set; }
     }
 }
 

src/CodeQLToolkit.Features.Test/Commands/Targets/Actions/ExecuteUnitTestsCommandTarget.cs

@@ -72,7 +72,7 @@ public override void Run()
                          process.StartInfo.UseShellExecute = false;
                          process.StartInfo.RedirectStandardOutput = true;
                          process.StartInfo.RedirectStandardError = false;
-                         process.StartInfo.Arguments = $"test run --failing-exitcode=122 --slice={slice+1}/{NumThreads} --ram=2048 --format=json --search-path={Language} {testPathString}";
+                         process.StartInfo.Arguments = $"test run {ExtraCodeQLArgs} --failing-exitcode=122 --slice={slice+1}/{NumThreads} --ram=2048 --format=json --search-path={Language} {testPathString}";
 
                          process.Start();
 

src/CodeQLToolkit.Features.Test/Commands/TestCommandFeature.cs

@@ -51,15 +51,17 @@ public void Register(Command parentCommand)
             var workDirectoryOption = new Option<string>("--work-dir", () => Path.GetTempPath(), "Where to place intermediate execution output files.") { IsRequired = true };
             var languageOption = new Option<string>("--language", $"The language to run tests for.") { IsRequired = true }.FromAmong(SupportedLangauges.Select(x => x.ToOptionString()).ToArray());
             var runnerOSOption = new Option<string>("--runner-os", $"Label for the operating system running these tests.") { IsRequired = true };
-            var cliVersionOption = new Option<string>("--cli-version", $"The version of the cli running the tests.") { IsRequired = true };
-            var stdLibIdentOption = new Option<string>("--stdlib-ident", $"A string identifying the standard library used.") { IsRequired = true };
+            //var cliVersionOption = new Option<string>("--cli-version", $"The version of the cli running the tests.") { IsRequired = true };
+            //var stdLibIdentOption = new Option<string>("--stdlib-ident", $"A string identifying the standard library used.") { IsRequired = true };
+            var extraCodeQLOptions = new Option<string>("--codeql-args", $"Extra arguments to pass to CodeQL.") { IsRequired = false };
 
             unitTestsCommand.Add(numThreadsOption); 
             unitTestsCommand.Add(workDirectoryOption);
             unitTestsCommand.Add(languageOption);
             unitTestsCommand.Add(runnerOSOption);
-            unitTestsCommand.Add(cliVersionOption);
-            unitTestsCommand.Add(stdLibIdentOption);
+            //unitTestsCommand.Add(cliVersionOption);
+            //unitTestsCommand.Add(stdLibIdentOption);
+            unitTestsCommand.Add(extraCodeQLOptions);
 
             // a command validates the tests 
             var validateUnitTestsCommand = new Command("validate-unit-tests", "Validates a unit test run in a fashion suitable for use in CI/CD systems.");
@@ -89,8 +91,8 @@ public void Register(Command parentCommand)
 
             }, Globals.BasePathOption, Globals.AutomationTypeOption, matrixOSVersion);
 
-
-            unitTestsCommand.SetHandler((basePath, automationType, numThreads, workDirectory, language, runnerOS, cliVersion, stdLibIdent) => {
+            //stdLibIdent
+            unitTestsCommand.SetHandler((basePath, automationType, numThreads, workDirectory, language, runnerOS, extraArgs) => {
 
                 Log<TestCommandFeature>.G().LogInformation("Executing execute-unit-tests command...");
 
@@ -100,17 +102,38 @@ public void Register(Command parentCommand)
                     AutomationTypeHelper.AutomationTypeFromString(automationType)
                     );
 
+                // lookup cliVersion and stdLibIdent 
+                var c = new QLTConfig()
+                {
+                    Base = basePath
+                };
+
+                if (!File.Exists(c.CodeQLConfigFilePath))
+                {
+                    ProcessUtils.DieWithError($"Cannot read values from missing file {c.CodeQLConfigFilePath}");
+                }
+
+                var config = c.FromFile();
+
                 featureTarget.Base = basePath;
                 featureTarget.NumThreads = numThreads;
                 featureTarget.WorkDirectory = workDirectory;
                 featureTarget.Language = language;
                 featureTarget.RunnerOS = runnerOS;
-                featureTarget.CLIVersion = cliVersion;
-                featureTarget.STDLibIdent = stdLibIdent;
+                featureTarget.CLIVersion = c.CodeQLCLI;
+                featureTarget.STDLibIdent = c.CodeQLStandardLibrary;
+                featureTarget.ExtraCodeQLArgs = extraArgs;
 
                 featureTarget.Run();
 
-            }, Globals.BasePathOption, Globals.AutomationTypeOption, numThreadsOption, workDirectoryOption, languageOption, runnerOSOption, cliVersionOption, stdLibIdentOption);
+            }, Globals.BasePathOption, 
+               Globals.AutomationTypeOption, 
+               numThreadsOption,
+               workDirectoryOption, 
+               languageOption, 
+               runnerOSOption, 
+               extraCodeQLOptions
+            );
 
 
             validateUnitTestsCommand.SetHandler((resultsDirectory) =>

src/CodeQLToolkit.Features.Test/Lifecycle/BaseLifecycleTarget.cs

@@ -11,5 +11,7 @@ abstract public class BaseLifecycleTarget : ILifecycleTarget
         public int NumThreads { get; set; }     
         public string UseRunner { get; set; }   
 
+        public string ExtraArgs { get; set; }
+
     }
 }

src/CodeQLToolkit.Features.Test/Lifecycle/Targets/Actions/InitLifecycleTarget.cs

@@ -21,13 +21,21 @@ public override void Run()
             var tmpLanguage = Language;
             Language = null;
 
+            var codeqlArgs = "--threads=0";
+
+            if(ExtraArgs!= null && ExtraArgs.Length > 0) 
+            {
+                codeqlArgs = $"{codeqlArgs} {ExtraArgs}";
+            }
+
             WriteTemplateIfOverwriteOrNotExists("install-codeql", Path.Combine(Base, ".github", "actions", "install-codeql", "action.yml"), "install-codeql action");
             WriteTemplateIfOverwriteOrNotExists("install-qlt", Path.Combine(Base, ".github", "actions", "install-qlt", "action.yml"), "install-qlt action");
             WriteTemplateIfOverwriteOrNotExists("run-unit-tests", Path.Combine(Base, ".github", "workflows", $"run-codeql-unit-tests-{tmpLanguage}.yml"), $"Run CodeQL Unit Tests ({Language})", new
             {
                 numThreads = NumThreads,
                 useRunner = UseRunner,
-                language = tmpLanguage
+                language = tmpLanguage,
+                codeqlArgs = codeqlArgs
             });
 
             Language = tmpLanguage; 

src/CodeQLToolkit.Features.Test/Lifecycle/TestLifecycleFeature.cs

@@ -37,19 +37,20 @@ public void Register(Command parentCommand)
             var numThreadsOption = new Option<int>("--num-threads", () => 4, "Number of threads to use during test execution.");
             var useRunnerOption = new Option<string>("--use-runner", () => "ubuntu-latest", "The runner(s) to use. Should be a comma-seperated list of actions runners.");
             var languageOption = new Option<string>("--language", $"The language to generate automation for.") { IsRequired = true }.FromAmong(SupportedLangauges.Select(x => x.ToOptionString()).ToArray());
+            var extraCodeQLOptions = new Option<string>("--codeql-args", $"Extra arguments to pass to CodeQL.") { IsRequired = false };
 
             initCommand.AddOption(overwriteExistingOption);
             initCommand.AddOption(numThreadsOption);
             initCommand.AddOption(useRunnerOption);
             initCommand.AddOption(languageOption);
-
+            initCommand.AddOption(extraCodeQLOptions);
 
 
             parentCommand.Add(initCommand);
 
 
 
-            initCommand.SetHandler((basePath, automationType, overwriteExisting, numThreads, useRunner, language) =>
+            initCommand.SetHandler((basePath, automationType, overwriteExisting, numThreads, useRunner, language, extraArgs) =>
             {
                 Log<TestLifecycleFeature>.G().LogInformation("Executing init command...");
 
@@ -65,10 +66,10 @@ public void Register(Command parentCommand)
                 featureTarget.NumThreads = numThreads;
                 featureTarget.UseRunner = useRunner;    
                 featureTarget.Language = language;
-
+                featureTarget.ExtraArgs = extraArgs;
                 featureTarget.Run();
 
-            }, Globals.BasePathOption, Globals.AutomationTypeOption, overwriteExistingOption, numThreadsOption, useRunnerOption, languageOption);
+            }, Globals.BasePathOption, Globals.AutomationTypeOption, overwriteExistingOption, numThreadsOption, useRunnerOption, languageOption, extraCodeQLOptions);
 
         }
 

src/CodeQLToolkit.Features.Test/Templates/Test/Actions/run-unit-tests.liquid

@@ -88,11 +88,10 @@ jobs:
         run: >
 {% endraw %}
           qlt test run execute-unit-tests  
+          --codeql-args "{{ codeql_args }}"
           --num-threads {{ num_threads }} 
           --language {{ language }} 
           --runner-os $RUNNER_OS 
-          --cli-version $CODEQL_CLI
-          --stdlib-ident $CODEQL_STDLIB_IDENT 
           --work-dir $RUNNER_TMP
 {% raw %}            
       - name: Upload test results