Exemplo n.º 1
0
        public void AddProjectToSolutionPostActionFindsOneProjectToAdd()
        {
            IPostAction postAction = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
                {
                    { "primaryOutputIndexes", "0" }
                }
            };

            ICreationResult creationResult = new MockCreationResult()
            {
                PrimaryOutputs = new List <ICreationPath>()
                {
                    new MockCreationPath()
                    {
                        Path = "outputProj1.csproj"
                    }
                }
            };

            Assert.True(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(EngineEnvironmentSettings, postAction, creationResult, string.Empty, out IReadOnlyList <string> foundProjectFiles));
            Assert.Equal(1, foundProjectFiles.Count);
            Assert.Equal(creationResult.PrimaryOutputs[0].Path, foundProjectFiles[0]);
        }
Exemplo n.º 2
0
        public void AddProjectToSolutionPostActionDoesntFindProjectOutOfRange()
        {
            IPostAction postAction = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
                {
                    { "primaryOutputIndexes", "1" }
                }
            };

            ICreationResult creationResult = new MockCreationResult()
            {
                PrimaryOutputs = new List <ICreationPath>()
                {
                    new MockCreationPath()
                    {
                        Path = "outputProj1.csproj"
                    },
                }
            };

            Assert.False(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(EngineEnvironmentSettings, postAction, creationResult, string.Empty, out IReadOnlyList <string> foundProjectFiles));
            Assert.Null(foundProjectFiles);
        }
        public void AddProjectToSolutionPostActionFindsMultipleProjectsToAdd()
        {
            string      outputBasePath = FileSystemHelpers.GetNewVirtualizedPath(_engineEnvironmentSettings);
            IPostAction postAction     = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
                {
                    { "primaryOutputIndexes", "0; 2" }
                }
            };

            ICreationResult creationResult = new MockCreationResult(
                primaryOutputs: new[]
            {
                new MockCreationPath(Path.GetFullPath("outputProj1.csproj")),
                new MockCreationPath(Path.GetFullPath("dontFindMe.csproj")),
                new MockCreationPath(Path.GetFullPath("outputProj2.csproj"))
            });

            Assert.True(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(postAction, creationResult, outputBasePath, out IReadOnlyList <string>?foundProjectFiles));
            Assert.Equal(2, foundProjectFiles?.Count);
            Assert.Contains(creationResult.PrimaryOutputs[0].Path, foundProjectFiles?.ToList());
            Assert.Contains(creationResult.PrimaryOutputs[2].Path, foundProjectFiles?.ToList());

            Assert.DoesNotContain(creationResult.PrimaryOutputs[1].Path, foundProjectFiles?.ToList());
        }
        public void AddProjectToSolutionPostActionWithoutPrimaryOutputIndexesWithOutputBasePath()
        {
            string outputBasePath = FileSystemHelpers.GetNewVirtualizedPath(EngineEnvironmentSettings);

            IPostAction postAction = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
            };

            ICreationResult creationResult = new MockCreationResult()
            {
                PrimaryOutputs = new List <ICreationPath>()
                {
                    new MockCreationPath()
                    {
                        Path = "outputProj1.csproj"
                    },
                    new MockCreationPath()
                    {
                        Path = "outputProj2.csproj"
                    },
                }
            };
            string outputFileFullPath0 = Path.Combine(outputBasePath, creationResult.PrimaryOutputs[0].Path);
            string outputFileFullPath1 = Path.Combine(outputBasePath, creationResult.PrimaryOutputs[1].Path);

            Assert.True(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(EngineEnvironmentSettings, postAction, creationResult, outputBasePath, out IReadOnlyList <string> foundProjectFiles));
            Assert.Equal(2, foundProjectFiles.Count);
            Assert.Contains(outputFileFullPath0, foundProjectFiles.ToList());
            Assert.Contains(outputFileFullPath1, foundProjectFiles.ToList());
        }
Exemplo n.º 5
0
        public void AddProjectToSolutionPostActionFindSolutionFileAtOutputPath()
        {
            string targetBasePath       = FileSystemHelpers.GetNewVirtualizedPath(EngineEnvironmentSettings);
            string solutionFileFullPath = Path.Combine(targetBasePath, "MySln.sln");

            EngineEnvironmentSettings.Host.FileSystem.WriteAllText(solutionFileFullPath, string.Empty);

            IReadOnlyList <string> solutionFiles = AddProjectsToSolutionPostAction.FindSolutionFilesAtOrAbovePath(EngineEnvironmentSettings.Host.FileSystem, targetBasePath);

            Assert.Equal(1, solutionFiles.Count);
            Assert.Equal(solutionFileFullPath, solutionFiles[0]);
        }
        public void AddProjectToSolutionPostActionDoesntFindProjectOutOfRange()
        {
            IPostAction postAction = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
                {
                    { "primaryOutputIndexes", "1" }
                }
            };

            ICreationResult creationResult = new MockCreationResult(primaryOutputs: new[] { new MockCreationPath("outputProj1.csproj") });

            Assert.False(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(postAction, creationResult, string.Empty, out IReadOnlyList <string>?foundProjectFiles));
            Assert.Null(foundProjectFiles);
        }
Exemplo n.º 7
0
        public void AddProjectToSolutionPostActionFindsMultipleProjectsToAdd()
        {
            IPostAction postAction = new MockPostAction()
            {
                ActionId = AddProjectsToSolutionPostAction.ActionProcessorId,
                Args     = new Dictionary <string, string>()
                {
                    { "primaryOutputIndexes", "0; 2" }
                }
            };

            ICreationResult creationResult = new MockCreationResult()
            {
                PrimaryOutputs = new List <ICreationPath>()
                {
                    new MockCreationPath()
                    {
                        Path = "outputProj1.csproj"
                    },
                    new MockCreationPath()
                    {
                        Path = "dontFindMe.csproj"
                    },
                    new MockCreationPath()
                    {
                        Path = "outputProj2.csproj"
                    },
                }
            };

            Assert.True(AddProjectsToSolutionPostAction.TryGetProjectFilesToAdd(_engineEnvironmentSettings, postAction, creationResult, string.Empty, out IReadOnlyList <string> foundProjectFiles));
            Assert.Equal(2, foundProjectFiles.Count);
            Assert.Contains(creationResult.PrimaryOutputs[0].Path, foundProjectFiles.ToList());
            Assert.Contains(creationResult.PrimaryOutputs[2].Path, foundProjectFiles.ToList());

            Assert.DoesNotContain(creationResult.PrimaryOutputs[1].Path, foundProjectFiles.ToList());
        }