make migration backup folder a sibling of the project root

src/Microsoft.DotNet.ProjectJsonMigration/Microsoft.DotNet.Internal.ProjectModel/Utilities/PathUtility.cs

@@ -25,7 +25,7 @@ namespace Microsoft.DotNet.Internal.ProjectModel.Utilities
             return candidate.StartsWith(dir, StringComparison.OrdinalIgnoreCase);
         }
 
-        public static string EnsureTrailingSlash(string path)
+        public static string EnsureTrailingSlash(this string path)
         {
             return EnsureTrailingCharacter(path, Path.DirectorySeparatorChar);
         }
@@ -54,9 +54,15 @@ namespace Microsoft.DotNet.Internal.ProjectModel.Utilities
         public static void EnsureParentDirectory(string filePath)
         {
             string directory = Path.GetDirectoryName(filePath);
-            if (!Directory.Exists(directory))
+
+            EnsureDirectory(directory);
+        }
+        
+        public static void EnsureDirectory(string directoryPath)
+        {
+            if (!Directory.Exists(directoryPath))
             {
-                Directory.CreateDirectory(directory);
+                Directory.CreateDirectory(directoryPath);
             }
         }
 

src/Microsoft.DotNet.ProjectJsonMigration/MigrationBackupPlan.cs

@@ -0,0 +1,90 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using Microsoft.DotNet.Internal.ProjectModel.Utilities;
+
+namespace Microsoft.DotNet.ProjectJsonMigration
+{
+    internal class MigrationBackupPlan
+    {
+        private readonly FileInfo globalJson;
+
+        public MigrationBackupPlan(
+            DirectoryInfo projectDirectory,
+            DirectoryInfo workspaceDirectory,
+            Func<DirectoryInfo, IEnumerable<FileInfo>> getFiles = null)
+        {
+            if (projectDirectory == null)
+            {
+                throw new ArgumentNullException(nameof(projectDirectory));
+            }
+            if (workspaceDirectory == null)
+            {
+                throw new ArgumentNullException(nameof(workspaceDirectory));
+            }
+
+            globalJson = new FileInfo(Path.Combine(
+                           workspaceDirectory.FullName,
+                           "global.json"));
+
+            projectDirectory = new DirectoryInfo(projectDirectory.FullName.EnsureTrailingSlash());
+            workspaceDirectory = new DirectoryInfo(workspaceDirectory.FullName.EnsureTrailingSlash());
+
+            RootBackupDirectory = new DirectoryInfo(
+                Path.Combine(
+                        workspaceDirectory.Parent.FullName,
+                        "backup")
+                    .EnsureTrailingSlash());
+
+            ProjectBackupDirectory = new DirectoryInfo(
+                Path.Combine(
+                        RootBackupDirectory.FullName,
+                        projectDirectory.Name)
+                    .EnsureTrailingSlash());
+
+            var relativeDirectory = PathUtility.GetRelativePath(
+                workspaceDirectory.FullName,
+                projectDirectory.FullName);
+
+            getFiles = getFiles ??
+                       (dir => dir.EnumerateFiles());
+
+            FilesToMove = getFiles(projectDirectory)
+               .Where(f => f.Name == "project.json"
+                        || f.Extension == ".xproj"
+                        || f.FullName.EndsWith(".xproj.user")
+                        || f.FullName.EndsWith(".lock.json"));
+        }
+
+        public DirectoryInfo ProjectBackupDirectory { get; }
+
+        public DirectoryInfo RootBackupDirectory { get; }
+
+        public IEnumerable<FileInfo> FilesToMove { get; }
+
+        public void PerformBackup()
+        {
+            if (globalJson.Exists)
+            {
+                PathUtility.EnsureDirectory(RootBackupDirectory.FullName);
+
+                globalJson.MoveTo(Path.Combine(
+                    ProjectBackupDirectory.Parent.FullName,
+                    globalJson.Name));
+            }
+
+            PathUtility.EnsureDirectory(ProjectBackupDirectory.FullName);
+
+            foreach (var file in FilesToMove)
+            {
+                file.MoveTo(
+                    Path.Combine(
+                        ProjectBackupDirectory.FullName, file.Name));
+            }
+        }
+    }
+}

src/Microsoft.DotNet.TestFramework/TestDirectory.cs

@@ -27,9 +27,19 @@ namespace Microsoft.DotNet.TestFramework
 
         private static void EnsureExistsAndEmpty(string path)
         {
-            if (Directory.Exists(path))
+            var testDirectory = new DirectoryInfo(path);
+
+            var migrationBackupDirectory = new DirectoryInfo(
+                System.IO.Path.Combine(testDirectory.Parent.FullName, "backup"));
+
+            if (testDirectory.Exists)
             {
-                Directory.Delete(path, true);
+                testDirectory.Delete(true);
+            } 
+            
+            if (migrationBackupDirectory.Exists)
+            {
+                migrationBackupDirectory.Delete(true);
             }
 
             Directory.CreateDirectory(path);

src/dotnet/commands/dotnet-migrate/MigrateCommand.cs

@@ -21,7 +21,6 @@ namespace Microsoft.DotNet.Tools.Migrate
     {
         private SlnFile _slnFile;
         private readonly DirectoryInfo _workspaceDirectory;
-        private readonly DirectoryInfo _backupDirectory;
         private readonly string _templateFile;
         private readonly string _projectArg;
         private readonly string _sdkVersion;
@@ -32,21 +31,20 @@ namespace Microsoft.DotNet.Tools.Migrate
         private readonly bool _skipBackup;
 
         public MigrateCommand(
-            string templateFile, 
+            string templateFile,
-            string projectArg, 
+            string projectArg,
-            string sdkVersion, 
+            string sdkVersion,
-            string xprojFilePath, 
+            string xprojFilePath,
-            string reportFile, 
+            string reportFile,
-            bool skipProjectReferences, 
+            bool skipProjectReferences,
             bool reportFormatJson,
             bool skipBackup)
-        {            
+        {
             _templateFile = templateFile;
             _projectArg = projectArg ?? Directory.GetCurrentDirectory();
             _workspaceDirectory = File.Exists(_projectArg)
                 ? new FileInfo(_projectArg).Directory
                 : new DirectoryInfo(_projectArg);
-            _backupDirectory = new DirectoryInfo(Path.Combine(_workspaceDirectory.FullName, "backup"));
             _sdkVersion = sdkVersion;
             _xprojFilePath = xprojFilePath;
             _skipProjectReferences = skipProjectReferences;
@@ -136,60 +134,24 @@ namespace Microsoft.DotNet.Tools.Migrate
             {
                 return;
             }
-            
+
             if (migrationReport.FailedProjectsCount > 0)
             {
                 return;
             }
-            
-            BackupGlobalJson();
 
             BackupProjects(migrationReport);
-            
         }
 
-        private void BackupGlobalJson()
-        {   
-            _backupDirectory.Create();
-
-            var globalJson = Path.Combine(_workspaceDirectory.FullName, GlobalSettings.FileName);
-
-            if (File.Exists(globalJson))
-            {
-                File.Move(globalJson, Path.Combine(_backupDirectory.FullName, GlobalSettings.FileName));
-            }
-        }
-        
         private void BackupProjects(MigrationReport migrationReport)
         {
             foreach (var report in migrationReport.ProjectMigrationReports)
             {
-                MigrateProject(report);
+                var backupPlan = new MigrationBackupPlan(
-            }
+                    new DirectoryInfo(report.ProjectDirectory),
-        }
+                    _workspaceDirectory);
 
-        private void MigrateProject(ProjectMigrationReport report)
+                backupPlan.PerformBackup();
-        {
-            var projectDirectory = PathUtility.EnsureTrailingSlash(report.ProjectDirectory);
-            
-            var relativeDirectory = PathUtility.GetRelativePath(PathUtility.EnsureTrailingSlash(_workspaceDirectory.FullName), projectDirectory);
-
-            var targetDirectory = String.IsNullOrEmpty(relativeDirectory)
-                ? _backupDirectory.FullName
-                :  Path.Combine(_backupDirectory.FullName, relativeDirectory);
-
-            PathUtility.EnsureDirectory(PathUtility.EnsureTrailingSlash(targetDirectory));
-
-            var movableFiles = new DirectoryInfo(projectDirectory)
-                .EnumerateFiles()
-                .Where(f => f.Name == Project.FileName 
-                         || f.Extension == ".xproj"
-                         || f.FullName.EndsWith(".xproj.user")
-                         || f.FullName.EndsWith(".lock.json"));
-            
-            foreach (var movableFile in movableFiles)
-            {
-                movableFile.MoveTo(Path.Combine(targetDirectory, movableFile.Name));
             }
         }
 
@@ -337,8 +299,8 @@ namespace Microsoft.DotNet.Tools.Migrate
             {
                 throw new Exception($"Invalid project argument - '{projectArg}' is not a project.json, global.json, or solution.sln file and a directory named '{projectArg}' doesn't exist.");
             }
-            
+
-            foreach(var project in projects)
+            foreach (var project in projects)
             {
                 yield return GetProjectJsonPath(project);
             }

test/Microsoft.DotNet.ProjectJsonMigration.Tests/MigrationBackupPlanTests.cs

@@ -0,0 +1,94 @@
+// Copyright (c) .NET Foundation and contributors. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full license information.
+
+using FluentAssertions;
+using Microsoft.DotNet.Internal.ProjectModel.Utilities;
+using Microsoft.DotNet.ProjectJsonMigration;
+using System;
+using System.IO;
+using System.Linq;
+using Xunit;
+
+namespace Microsoft.DotNet.ProjectJsonMigration.Tests
+{
+    public partial class MigrationBackupPlanTests
+    {
+        [Fact]
+        public void TheRootBackupDirectoryIsASiblingOfTheRootProject()
+        {
+            var dir = new DirectoryInfo(Path.Combine("src", "some-proj"));
+
+            System.Console.WriteLine(dir.FullName);
+
+            WhenMigrating(
+                projectDirectory: dir.FullName,
+                workspaceDirectory: Path.Combine("src", "RootProject"))
+            .RootBackupDirectory
+            .FullName
+            .Should()
+            .Be(new DirectoryInfo(Path.Combine("src", "backup")).FullName.EnsureTrailingSlash());
+        }
+
+        [Fact]
+        public void TheRootProjectsBackupDirectoryIsASubfolderOfTheRootBackupDirectory()
+        {
+            WhenMigrating(
+                projectDirectory: Path.Combine("src", "RootProject"),
+                workspaceDirectory: Path.Combine("src", "RootProject"))
+            .ProjectBackupDirectory
+            .FullName
+            .Should()
+            .Be(new DirectoryInfo(Path.Combine("src", "backup", "RootProject")).FullName.EnsureTrailingSlash());
+        }
+
+        [Fact]
+        public void ADependentProjectsMigrationBackupDirectoryIsASubfolderOfTheRootBackupDirectory()
+        {
+            WhenMigrating(
+                 projectDirectory: Path.Combine("src", "Dependency"),
+                 workspaceDirectory: Path.Combine("src", "RootProject"))
+             .ProjectBackupDirectory
+             .FullName
+             .Should()
+             .Be(new DirectoryInfo(Path.Combine("src", "backup", "Dependency")).FullName.EnsureTrailingSlash());
+        }
+
+        [Fact]
+        public void FilesToBackUpAreIdentifiedInTheTheRootProjectDirectory()
+        {
+            var root = new DirectoryInfo(Path.Combine("src", "RootProject"));
+
+            WhenMigrating(
+                projectDirectory: root.FullName,
+                workspaceDirectory: root.FullName)
+            .FilesToMove
+            .Should()
+            .Contain(_ => _.FullName == Path.Combine(root.FullName, "project.json"));
+
+        }
+
+        [Fact]
+        public void FilesToBackUpAreIdentifiedInTheTheDependencyProjectDirectory()
+        {
+            var root = new DirectoryInfo(Path.Combine("src", "RootProject"));
+            var dependency = new DirectoryInfo(Path.Combine("src", "RootProject"));
+
+            WhenMigrating(
+                projectDirectory: dependency.FullName,
+                workspaceDirectory: root.FullName)
+            .FilesToMove
+            .Should()
+            .Contain(_ => _.FullName == Path.Combine(dependency.FullName, "project.json"));
+
+        }
+
+        private MigrationBackupPlan WhenMigrating(
+            string projectDirectory,
+            string workspaceDirectory) =>
+            new MigrationBackupPlan(
+                new DirectoryInfo(projectDirectory),
+                new DirectoryInfo(workspaceDirectory),
+                dir => new[] { new FileInfo(Path.Combine(dir.FullName, "project.json")) });
+
+    }
+}

test/Microsoft.DotNet.Tools.Tests.Utilities/Extensions/TestCommandExtensions.cs

@@ -48,7 +48,7 @@ namespace Microsoft.DotNet.Tools.Test.Utilities
             return subject;
         }
         
-        public static TCommand WithForwardingToConsole<TCommand>(this TCommand subject, Action<string> writeLine) where TCommand : TestCommand
+        public static TCommand WithForwardingToConsole<TCommand>(this TCommand subject) where TCommand : TestCommand
         {
             subject.WithOutputDataReceivedHandler(s => Console.Out.WriteLine(s));
 

test/dotnet-migrate.Tests/GivenThatAnAppWasMigrated.cs

@@ -12,18 +12,47 @@ namespace Microsoft.DotNet.Migration.Tests
     public class GivenThatAnAppWasMigrated : TestBase
     {
         [Theory]
-        [InlineData("PJTestAppSimple")]
         [InlineData("TestAppWithLibrary")]
-        public void When_migration_succeeds_Then_project_json_artifacts_get_moved_to_backup(string testProjectName)
+        public void WhenProjectMigrationSucceedsThenProjectJsonArtifactsGetMovedToBackup(string testProjectName)
         {
             var testRoot = TestAssetsManager
-                .CreateTestInstance(testProjectName, identifier: testProjectName)
+                .CreateTestInstance(testProjectName)
                 .Path;
 
-            var backupRoot = Path.Combine(testRoot, "backup");
+            var testRootParent = new DirectoryInfo(testRoot).Parent.FullName;
+
+            var backupRoot = Path.Combine(testRootParent, "backup");
 
             var migratableArtifacts = GetProjectJsonArtifacts(testRoot);
-            
+
+            new MigrateCommand()
+                .WithWorkingDirectory(testRoot)
+                .Execute()
+                .Should().Pass();
+
+            var backupArtifacts = GetProjectJsonArtifacts(backupRoot);
+
+            backupArtifacts.Should().Equal(migratableArtifacts, "Because all of and only these artifacts should have been moved");
+
+            new DirectoryInfo(testRoot).Should().NotHaveFiles(backupArtifacts.Keys);
+
+            new DirectoryInfo(backupRoot).Should().HaveTextFiles(backupArtifacts);
+        }
+
+        [Theory]
+        [InlineData("PJTestAppSimple")]
+        public void WhenFolderMigrationSucceedsThenProjectJsonArtifactsGetMovedToBackup(string testProjectName)
+        {
+            var testRoot = TestAssetsManager
+                .CreateTestInstance(testProjectName)
+                .Path;
+
+            var testRootParent = new DirectoryInfo(testRoot).Parent.FullName;
+
+            var backupRoot = Path.Combine(testRootParent, "backup", testProjectName);
+
+            var migratableArtifacts = GetProjectJsonArtifacts(testRoot);
+
             new MigrateCommand()
                 .WithWorkingDirectory(testRoot)
                 .Execute()
@@ -40,7 +69,7 @@ namespace Microsoft.DotNet.Migration.Tests
 
         [Theory]
         [InlineData("TestAppWithLibraryAndMissingP2P")]
-        public void When_migration_fails_Then_project_json_artifacts_do_not_get_moved_to_backup(string testProjectName)
+        public void WhenMigrationFailsThenProjectJsonArtifactsDoNotGetMovedToBackup(string testProjectName)
         {
             var testRoot = new TestAssetsManager(Path.Combine(RepoRoot, "TestAssets", "NonRestoredTestProjects"))
                 .CreateTestInstance(testProjectName, identifier: testProjectName)
@@ -54,7 +83,7 @@ namespace Microsoft.DotNet.Migration.Tests
                 .WithWorkingDirectory(testRoot)
                 .Execute()
                 .Should().Fail();
-            
+
             new DirectoryInfo(backupRoot).Should().NotExist("Because migration failed and therefore no backup is needed.");
 
             new DirectoryInfo(testRoot).Should().HaveTextFiles(migratableArtifacts, "Because migration failed so nothing was moved to backup.");
@@ -62,7 +91,7 @@ namespace Microsoft.DotNet.Migration.Tests
 
         [Theory]
         [InlineData("PJTestAppSimple")]
-        public void When_skipbackup_specified_Then_project_json_artifacts_do_not_get_moved_to_backup(string testProjectName)
+        public void WhenSkipbackupSpecifiedThenProjectJsonArtifactsDoNotGetMovedToBackup(string testProjectName)
         {
             var testRoot = TestAssetsManager.CreateTestInstance(testProjectName, identifier: testProjectName).Path;
 
@@ -74,7 +103,7 @@ namespace Microsoft.DotNet.Migration.Tests
                 .WithWorkingDirectory(testRoot)
                 .Execute("--skip-backup")
                 .Should().Pass();
-            
+
             new DirectoryInfo(backupRoot).Should().NotExist("Because --skip-backup was specified.");
 
             new DirectoryInfo(testRoot).Should().HaveTextFiles(migratableArtifacts, "Because --skip-backup was specified.");
@@ -83,14 +112,14 @@ namespace Microsoft.DotNet.Migration.Tests
         private Dictionary<string, string> GetProjectJsonArtifacts(string rootPath)
         {
             var catalog = new Dictionary<string, string>();
-            
+
-            var patterns = new [] { "global.json", "project.json", "project.lock.json", "*.xproj", "*.xproj.user" };
+            var patterns = new[] { "global.json", "project.json", "project.lock.json", "*.xproj", "*.xproj.user" };
 
             foreach (var pattern in patterns)
             {
                 AddArtifactsToCatalog(catalog, rootPath, pattern);
             }
-            
+
             return catalog;
         }
 
@@ -104,7 +133,8 @@ namespace Microsoft.DotNet.Migration.Tests
 
             foreach (var file in files)
             {
-                catalog.Add(PathUtility.GetRelativePath(basePath, file.FullName), File.ReadAllText(file.FullName));
+                var key = PathUtility.GetRelativePath(basePath, file.FullName);
+                catalog.Add(key, File.ReadAllText(file.FullName));
             }
         }
     }

test/dotnet-migrate.Tests/GivenThatIWantToMigrateTestApps.cs

@@ -210,7 +210,9 @@ namespace Microsoft.DotNet.Migration.Tests
         public void ItMigratesRootProjectAndReferences(string projectName, string expectedProjects)
         {
             var projectDirectory =
-                TestAssetsManager.CreateTestInstance("TestAppDependencyGraph", callingMethod: $"{projectName}.RefsTest").Path;
+                TestAssetsManager.CreateTestInstance(
+                    "TestAppDependencyGraph", 
+                    identifier: $"{projectName}.RefsTest").Path;
 
             MigrateProject(new [] { Path.Combine(projectDirectory, projectName) });
 
@@ -228,7 +230,7 @@ namespace Microsoft.DotNet.Migration.Tests
         public void ItMigratesRootProjectAndSkipsReferences(string projectName)
         {
             var projectDirectory =
-                TestAssetsManager.CreateTestInstance("TestAppDependencyGraph", callingMethod: $"{projectName}.SkipRefsTest").Path;
+                TestAssetsManager.CreateTestInstance("TestAppDependencyGraph", identifier: $"{projectName}.SkipRefsTest").Path;
 
             MigrateProject(new [] { Path.Combine(projectDirectory, projectName), "--skip-project-references" });
 
@@ -421,7 +423,7 @@ namespace Microsoft.DotNet.Migration.Tests
         {
             const string projectName = "ProjectA";
             var solutionDirectory =
-                TestAssetsManager.CreateTestInstance("TestAppDependencyGraph", callingMethod: "p").Path;
+                TestAssetsManager.CreateTestInstance("TestAppDependencyGraph").Path;
             var projectDirectory = Path.Combine(solutionDirectory, projectName);
 
             MigrateProject(new string[] { projectDirectory });
@@ -472,7 +474,7 @@ namespace Microsoft.DotNet.Migration.Tests
         public void ItMigratesAndBuildsLibrary(string projectName)
         {
             var projectDirectory = TestAssetsManager.CreateTestInstance(projectName,
-                callingMethod: $"{nameof(ItMigratesAndBuildsLibrary)}-projectName").Path;
+                identifier: $"{nameof(ItMigratesAndBuildsLibrary)}-{projectName}").Path;
 
             MigrateProject(projectDirectory);
             Restore(projectDirectory, projectName);
@@ -496,8 +498,7 @@ namespace Microsoft.DotNet.Migration.Tests
         public void ItMigratesSln()
         {
             var rootDirectory = TestAssetsManager.CreateTestInstance(
-                "TestAppWithSlnAndMultipleProjects",
+                "TestAppWithSlnAndMultipleProjects").Path;
-                callingMethod: "a").Path;
 
             var testAppProjectDirectory = Path.Combine(rootDirectory, "TestApp");
             var testLibProjectDirectory = Path.Combine(rootDirectory, "TestLibrary");
@@ -670,6 +671,7 @@ namespace Microsoft.DotNet.Migration.Tests
 
             var result = new BuildPJCommand()
                 .WithCapturedOutput()
+                .WithForwardingToConsole()
                 .Execute(projectFile);
 
             result.Should().Pass();
@@ -677,10 +679,11 @@ namespace Microsoft.DotNet.Migration.Tests
 
         private void MigrateProject(params string[] migrateArgs)
         {
-            var result =
+            new TestCommand("dotnet")
-                MigrateCommand.Run(migrateArgs);
+                    .WithForwardingToConsole()
-
+                    .Execute($"migrate {string.Join(" ", migrateArgs)}")
-            result.Should().Be(0);
+                    .Should()
+                    .Pass();
         }
 
         private void RestoreProjectJson(string projectDirectory)