Exemple #1
0
        public static IProcess AssertZeroExitCode(
            [AssertionCondition(AssertionConditionType.IS_NOT_NULL)][CanBeNull]
            this IProcess process)
        {
            const string indentation = "   ";

            process.AssertWaitForExit();
            if (process.ExitCode != 0)
            {
                var messageBuilder = new StringBuilder()
                                     .AppendLine($"Process '{Path.GetFileName(process.FileName)}' exited with code {process.ExitCode}.")
                                     .AppendLine("Invocation:")
                                     .AppendLine($"{indentation}{process.FileName.DoubleQuoteIfNeeded()} {process.Arguments}")
                                     .AppendLine("Working directory:")
                                     .AppendLine($"{indentation}{process.WorkingDirectory}");

                var errorOutput = process.Output.Where(x => x.Type == OutputType.Err).ToList();
                if (errorOutput.Count > 0)
                {
                    messageBuilder.AppendLine("Error output:");
                    errorOutput.ForEach(x => messageBuilder.Append(indentation).AppendLine(x.Text));
                }
                else if (Logger.LogLevel <= LogLevel.Trace)
                {
                    messageBuilder.AppendLine("Standard output:");
                    process.Output.ForEach(x => messageBuilder.Append(indentation).AppendLine(x.Text));
                }

                ControlFlow.Fail(messageBuilder.ToString());
            }

            return(process);
        }
Exemple #2
0
        private static void AssertProcess(IProcess process, Xunit2Settings toolSettings)
        {
            process.AssertWaitForExit();
            switch (process.ExitCode)
            {
            case 0:
                break;

            case 1:
                ControlFlow.Fail("One or more of the tests failed.");
                break;

            case 2:
                ControlFlow.Fail(
                    "The help page was shown, either because it was requested, or because the user did not provide any command line arguments.");
                break;

            case 3:
                ControlFlow.Fail("There was a problem with one of the command line options passed to the runner.");
                break;

            case 4:
                ControlFlow.Fail(
                    "There was a problem loading one or more of the test assemblies (for example, if a 64-bit only assembly is run with the 32-bit test runner).");
                break;

            default:
                throw new NotSupportedException();
            }
        }
Exemple #3
0
        /// <summary>
        /// Ensures that GitVersion has a system wide environment variable set.  If not it will attempt to locate it and set the environment variable.
        /// </summary>
        /// <param name="targetEnvironment">Whether to target user or system/machine setting.  You must run the app as administrator to use Machine.</param>
        /// <returns></returns>
        public static bool ValidateGetVersionEnvVariable(EnvironmentVariableTarget targetEnvironment = EnvironmentVariableTarget.Process)
        {
            string envGitVersion = Environment.GetEnvironmentVariable(ENV_GITVERSION);


            if (envGitVersion == null)
            {
                Logger.Warn("GitVersion environment variable not found.  Will attempt to set.");

                string cmd     = "where";
                string cmdArgs = "gitversion.exe";

                IProcess process = ProcessTasks.StartProcess(cmd, cmdArgs, logOutput: true);
                process.AssertWaitForExit();
                ControlFlow.Assert(process.ExitCode == 0, "The " + ENV_GITVERSION + " environment variable is not set and attempt to fix it, failed because it appears GitVersion is not installed on the local machine.  Install it and then re-run and/or set the environment variable manually");

                // Set the environment variable now that we found it
                string value = process.Output.First().Text;
                Environment.SetEnvironmentVariable(ENV_GITVERSION, value, targetEnvironment);
                envGitVersion = Environment.GetEnvironmentVariable(ENV_GITVERSION);
                string val = ToolPathResolver.TryGetEnvironmentExecutable("GITVERSION_EXE");
                Console.WriteLine("Toolpathresolver: " + val);
                Console.WriteLine();
                string msg =
                    "GitVersion Environment variable has been set!  You will need to ensure you close the current console window before continuing to pickup the change.";
                Console.WriteWithGradient(msg, Color.Fuchsia, Color.Yellow, 16);
                Console.ReplaceAllColorsWithDefaults();
            }

            return(true);
        }
Exemple #4
0
        /// <summary>
        /// Executes the requested Git Command AND returns the output.  Returns True on success, false otherwise
        /// </summary>
        /// <param name="cmdArguments"></param>
        /// <param name="output"></param>
        /// <returns></returns>
        private bool ExecuteGit(string cmdArguments, out List <Output> output)
        {
            string command = "git";


            // Log it
            Output outputCmd = new Output();

            outputCmd.Text = GIT_COMMAND_MARKER + command + " " + cmdArguments;
            GitCommandOutputHistory.Add(outputCmd);

            IProcess process = ProcessTasks.StartProcess(command, cmdArguments, RootDirectory, logOutput: false);

            process.AssertWaitForExit();
            output = process.Output.ToList();

            // Copy output to history.
            GitCommandOutputHistory.AddRange(process.Output);

            if (process.ExitCode != 0)
            {
                return(false);
            }
            return(true);
        }
Exemple #5
0
        /// <summary>
        /// Executes the requested Git Command AND returns the output.  Returns True on success, false otherwise
        /// </summary>
        /// <param name="cmdArguments"></param>
        /// <param name="output"></param>
        /// <returns></returns>
        private bool ExecuteGit(string cmdArguments, out List <LineOutColored> output)
        {
            string command = GIT_COMMAND;

            HasErrored = false;

            // Log it
            LineOutColored outputCmd = LineOutColored.Normal(GIT_COMMAND_MARKER + command + " " + cmdArguments);

            GitCommandOutputHistory.Add(outputCmd);

            //ProcessTasks.DefaultLogOutput = false;
            IProcess process = ProcessTasks.StartProcess(command, cmdArguments, CISession.RootDirectory, logInvocation: logInvocationLogging, logOutput: logOutputLogging);

            //,customLogger:GitProcessorLoggerNormal
            process.AssertWaitForExit();
            output = process.Output.ToList();

            // Copy output to history.
            GitCommandOutputHistory.AddRange(process.Output);

            if (process.ExitCode != 0)
            {
                HasErrored = true;
                return(false);
            }
            return(true);
        }
Exemple #6
0
 public static void AssertZeroExitCode([AssertionCondition(AssertionConditionType.IS_NOT_NULL)][CanBeNull] this IProcess process)
 {
     process.AssertWaitForExit();
     ControlFlow.Assert(process.ExitCode == 0,
                        new[]
     {
         $"Process '{Path.GetFileName(process.FileName)}' exited with code {process.ExitCode}. Please verify the invocation.",
         $"> {process.FileName.DoubleQuoteIfNeeded()} {process.Arguments}"
     }.JoinNewLine());
 }
        private bool MoveProjectStepB(VisualStudioProject project)
        {
            // Now add it back to project with new location
            string   addParam = Path.Combine(project.NewPath, project.Namecsproj);
            IProcess sln      = ProcessTasks.StartProcess(DotNetPath, "sln " + ExpectedSolutionPath + " add " + addParam, logOutput: true);

            sln.AssertWaitForExit();
            ControlFlow.Assert(sln.ExitCode == 0, "Failed to re-add Project: " + project.Name + " to solution so we could complete the move");

            Logger.Success("Project: {0} successfully relocated into proper new directory layout.", project.Name);
            return(true);
        }
        public static IProcess AssertZeroExitCode(
            [AssertionCondition(AssertionConditionType.IS_NOT_NULL)][CanBeNull]
            this IProcess process)
        {
            process.AssertWaitForExit();

            if (process.ExitCode != 0)
            {
                throw new ProcessException(process);
            }

            return(process);
        }
        /// <summary>
        /// Moves a project of a solution:  Moves it's folder location to new location and then updates the solution.
        /// </summary>
        /// <param name="project">VisualStudioProject object representing the project to move.</param>
        /// <returns></returns>
        private bool MoveProjectStepA(VisualStudioProject project)
        {
            // Move project to new location
            if (project.OriginalPath.ToString() != project.NewPath.ToString())
            {
                Directory.Move(project.OriginalPath, project.NewPath);
            }

            // Remove from Solution
            string   removeParam = Path.Combine(project.OriginalPath, project.Namecsproj);
            IProcess sln         = ProcessTasks.StartProcess(DotNetPath, "sln " + CurrentSolutionPath + " remove " + removeParam, logOutput: true);

            sln.AssertWaitForExit();
            ControlFlow.Assert(sln.ExitCode == 0, "Failed to remove Project: " + project.Name + " from solution so we could move it.");

            return(true);
        }
        /// <summary>
        /// Run the typewriter publishing steps
        /// </summary>
        /// <returns></returns>
        protected override StageCompletionStatusEnum ExecuteProcess()
        {
            string command = "npm";
            string npmArgs = "run publishTW";

            CompletionStatus = StageCompletionStatusEnum.InProcess;

            foreach (SlugCIProject project in CISession.Projects)
            {
                AOT_Normal("Project: " + project.Name, Color.Magenta);
                AOT_Normal("  --> HasTypeWriterScripts:  " + project.HasTypeWriterScripts, Color.Magenta);

                if (!project.HasTypeWriterScripts)
                {
                    continue;
                }


                AbsolutePath scriptsFolder = project.VSProject.Directory / "_scripts";
                IProcess     process       = ProcessTasks.StartProcess(command, npmArgs, scriptsFolder, customLogger: NPMLogger);
                process.AssertWaitForExit();

                StageOutput.AddRange(process.Output);

                if (process.ExitCode != 0)
                {
                    SetInprocessStageStatus(StageCompletionStatusEnum.Failure);
                }
                else
                {
                    SetInprocessStageStatus(StageCompletionStatusEnum.Success);
                }
            }

            if (CompletionStatus == StageCompletionStatusEnum.InProcess)
            {
                CompletionStatus = StageCompletionStatusEnum.Success;
            }

            return(CompletionStatus);
        }
Exemple #11
0
        /// <summary>
        /// Run the Angular Build
        /// </summary>
        /// <returns></returns>
        protected override StageCompletionStatusEnum ExecuteProcess()
        {
            string command = "ng";
            string ngArgs  = "build";

            if (CISession.SkipAngularBuild)
            {
                return(StageCompletionStatusEnum.Skipped);
            }

            CompletionStatus = StageCompletionStatusEnum.InProcess;

            foreach (AngularProject project in CISession.SlugCIConfigObj.AngularProjects)
            {
                AddOutputText("Project: " + project.Name, OutputType.Std);

                AbsolutePath angularProjectPath = CISession.AngularDirectory / project.Name;
                IProcess     process            = ProcessTasks.StartProcess(command, ngArgs, angularProjectPath, customLogger: AngularLogger);
                process.AssertWaitForExit();

                StageOutput.AddRange(process.Output);

                if (process.ExitCode != 0)
                {
                    SetInprocessStageStatus(StageCompletionStatusEnum.Failure);
                    project.Results.CompileSuccess = false;
                }
                else
                {
                    SetInprocessStageStatus(StageCompletionStatusEnum.Success);
                    project.Results.CompileSuccess = true;
                }
            }

            if (CompletionStatus == StageCompletionStatusEnum.InProcess)
            {
                CompletionStatus = StageCompletionStatusEnum.Success;
            }

            return(CompletionStatus);
        }
Exemple #12
0
        public static IProcess AssertZeroExitCode(
            [AssertionCondition(AssertionConditionType.IS_NOT_NULL)][CanBeNull]
            this IProcess process)
        {
            process.AssertWaitForExit();
            if (process.ExitCode != 0)
            {
                var messageBuilder = new StringBuilder()
                                     .AppendLine($"Process '{Path.GetFileName(process.FileName)}' exited with code {process.ExitCode}. Verify the invocation.")
                                     .AppendLine($"> {process.FileName.DoubleQuoteIfNeeded()} {process.Arguments}");

                var errorOutput = process.Output.Where(x => x.Type == OutputType.Err).Select(x => x.Text).ToList();
                if (errorOutput.Count > 0)
                {
                    messageBuilder.AppendLine("Error output:");
                    errorOutput.ForEach(x => messageBuilder.AppendLine(x));
                }

                ControlFlow.Fail(messageBuilder.ToString());
            }

            return(process);
        }
Exemple #13
0
        private static void AssertProcess(IProcess process, UnityBaseSettings settings)
        {
            process.AssertWaitForExit();
            AssertWatcherStopped();
            if (process.ExitCode == 0)
            {
                return;
            }

            var message = new StringBuilder()
                          .AppendLine($"Process '{Path.GetFileName(process.FileName)}' exited with code {process.ExitCode}. Verify the invocation.")
                          .AppendLine($"> {process.FileName.DoubleQuoteIfNeeded()} {process.Arguments}")
                          .ToString();

            if (settings.StableExitCodes.Any(x => x == process.ExitCode))
            {
                Logger.Warn(message);
            }
            else
            {
                ControlFlow.Fail(message);
            }
        }
        /// <summary>
        /// Ensure the Directory Structure is correct. Projects are in proper place.
        /// </summary>
        /// <param name="solutionFile"></param>
        /// <returns></returns>
        private bool ProperDirectoryStructure(string solutionFile)
        {
            // Create src folder if it does not exist.
            if (!DirectoryExists(SourceDirectory))
            {
                Directory.CreateDirectory(SourceDirectory.ToString());
            }

            // Create Tests folder if it does not exist.
            if (!DirectoryExists(TestsDirectory))
            {
                Directory.CreateDirectory(TestsDirectory.ToString());
            }

            // Create Artifacts / Output folder if it does not exist.
            if (!DirectoryExists(OutputDirectory))
            {
                Directory.CreateDirectory(OutputDirectory.ToString());
            }

            // Query the solution for the projects that are in it.
            // We allow all tests to run, instead of failing at first failure.
            CurrentSolutionPath = (AbsolutePath)Path.GetDirectoryName(solutionFile);

            DotNetPath = ToolPathResolver.GetPathExecutable("dotnet");
            IProcess slnfind = ProcessTasks.StartProcess(DotNetPath, "sln " + CurrentSolutionPath + " list", logOutput: true);

            slnfind.AssertWaitForExit();
            IReadOnlyCollection <Output> output = slnfind.Output;


            // There are 2 things we need to check.
            //  1.  Is solution in right folder?
            //  2.  Are projects in right folder.
            //  The Move process has to do the following:
            //   1. Move the project folder to proper place
            //   2. Remove the project from the solution
            //   3. Do steps 1, 2 for every project
            //   4. Move solution file to proper location
            //   5. Re-add all projects to solution
            bool solutionNeedsToMove = false;

            if (CurrentSolutionPath.ToString() != ExpectedSolutionPath.ToString())
            {
                solutionNeedsToMove = true;
            }

            List <VisualStudioProject> movedProjects = new List <VisualStudioProject>();

            // Step 3
            foreach (Output outputRec in output)
            {
                if (outputRec.Text.EndsWith(".csproj"))
                {
                    VisualStudioProject project = GetInitProject(outputRec.Text);
                    Projects.Add(project);

                    // Do we need to move the project?
                    if ((project.OriginalPath.ToString() != project.NewPath.ToString()) || solutionNeedsToMove)
                    {
                        movedProjects.Add(project);
                        MoveProjectStepA(project);
                    }
                }
            }

            // Step 4:  Is Solution in proper directory.  If not move it.
            if (solutionNeedsToMove)
            {
                string slnFileCurrent = CurrentSolutionPath / Path.GetFileName(solutionFile);
                string slnFileFuture  = ExpectedSolutionPath / Path.GetFileName(solutionFile);
                File.Move(slnFileCurrent, slnFileFuture);
            }


            // Step 5.  Read project to solution
            if (movedProjects.Count > 0)
            {
                foreach (VisualStudioProject project in movedProjects)
                {
                    MoveProjectStepB(project);
                }
            }
            return(true);
        }
        /// <summary>
        /// Run the Typewriter build process
        /// </summary>
        /// <returns></returns>
        protected override StageCompletionStatusEnum ExecuteProcess()
        {
            CompletionStatus = StageCompletionStatusEnum.InProcess;

            // Read the package.json file if necessary...
            foreach (SlugCIProject project in CISession.Projects)
            {
                AOT_Normal("Project: " + project.Name, Color.Magenta);
                AOT_Normal("  --> HasTypeWriterScripts:  " + project.HasTypeWriterScripts, Color.Magenta);
                if (!project.HasTypeWriterScripts)
                {
                    continue;
                }


                AbsolutePath scriptsFolder = project.VSProject.Directory / "_scripts";
                AOT_Normal("  --> Scripts Folder: " + scriptsFolder);

                AbsolutePath     scriptsFile      = scriptsFolder / "package.json";
                TypeWriterConfig typeWriterConfig = null;
                if (FileExists(scriptsFile))
                {
                    string Json = File.ReadAllText(scriptsFile);
                    typeWriterConfig = JsonSerializer.Deserialize <TypeWriterConfig>(Json, new JsonSerializerOptions {
                        PropertyNameCaseInsensitive = true
                    });
                }
                else
                {
                    AOT_Error("  --> package.json file was not found.");
                    ControlFlow.Assert(true == false, "Package.json file was not found");
                }


                // Make sure it has proper elements:
                bool updated = false;
                if (typeWriterConfig.Scripts.Pack == null || typeWriterConfig.Scripts.Pack != CMD_PACK)
                {
                    updated = true;
                    typeWriterConfig.Scripts.Pack = CMD_PACK;
                }
                if (typeWriterConfig.Scripts.PublishTW == null || typeWriterConfig.Scripts.PublishTW != CMD_PUBLISH)
                {
                    updated = true;
                    typeWriterConfig.Scripts.PublishTW = CMD_PUBLISH;
                }
                if (typeWriterConfig.Scripts.Copy == null || typeWriterConfig.Scripts.Copy != CMD_COPY)
                {
                    updated = true;
                    typeWriterConfig.Scripts.Copy = CMD_COPY;
                }

                if (typeWriterConfig.Version == null || typeWriterConfig.Version != CISession.VersionInfo.NPMVersion)
                {
                    updated = true;
                    typeWriterConfig.Version     = CISession.VersionInfo.NPMVersion;
                    typeWriterConfig.VersionFull = CISession.VersionInfo.SemVersionAsString;
                }

                if (updated)
                {
                    string json = JsonSerializer.Serialize <TypeWriterConfig>(typeWriterConfig, new JsonSerializerOptions {
                        WriteIndented = true, PropertyNamingPolicy = JsonNamingPolicy.CamelCase
                    });
                    File.WriteAllText(scriptsFile, json);
                }

                // Pack the files
                string   command = "npm";
                string   npmArgs = "run pack";
                IProcess process = ProcessTasks.StartProcess(command, npmArgs, scriptsFolder);
                process.AssertWaitForExit();
                StageOutput.AddRange(process.Output);

                if (process.ExitCode != 0)
                {
                    SetInprocessStageStatus(StageCompletionStatusEnum.Failure);
                }
                else
                {
                    CISession.GitProcessor.CommitChanges("TypeWriter Updates for project --> " + project.Name);
                    SetInprocessStageStatus(StageCompletionStatusEnum.Success);
                }


                //SetInprocessStageStatus(StageCompletionStatusEnum.Success);
            }

            if (CompletionStatus == StageCompletionStatusEnum.InProcess)
            {
                CompletionStatus = StageCompletionStatusEnum.Skipped;
            }

            return(CompletionStatus);
        }