Import BBS archive with migrate-repo command (#582)

Closes #528!
This PR updates the placeholder migrate-repo command for bbs2gh with real logic to ingest an archive URL and kick off a migration with Octoshift.
A few notes about this PR:

There are some parameters that pass strings like "not-used" to satisfy required parameters in GraphQL and Octoshift.  When github/octoshift#5350 is shipped, these "filler" strings can be removed.
CreateBbsMigrationSource was added to GithubApi.  This is consumed by the bbs2gh MigrateRepoCommand to kick off migrations over GraphQL.
bbs2gh.csproj was added as a reference to OctoshiftCLI.Tests.csproj.  This is necessary to test classes in the OctoshiftCLI.BbsToGithub.Commands namespace.
I opted to use a MigrateRepoCommandArgs class in bbs2gh's MigrateRepoCommand because I felt that it was cleaner and easier to read.
Some unused ADO logic was pulled from bbs2gh's EnvironmentVariableProvider.
As for test coverage, I opted to find parity in the coverage for the GEI tests that is relevant to bbs2gh.  I'm happy to add more coverage if desired 👍

Tasks

 Did you write/update appropriate tests
 Release notes updated (if appropriate)
 Appropriate logging output
 Issue linked
 Docs updated (or issue created) (added bullet point to #586)

Author: synthead

RELEASENOTES.md

@@ -1 +1 @@
-
+- Add `migrate-repo` command to `bbs2gh`.

src/Octoshift/GithubApi.cs

@@ -171,6 +171,32 @@ public virtual async Task<string> CreateAdoMigrationSource(string orgId, string
             return (string)data["data"]["createMigrationSource"]["migrationSource"]["id"];
         }
 
+        public virtual async Task<string> CreateBbsMigrationSource(string orgId)
+        {
+            var url = $"{_apiUrl}/graphql";
+
+            var query = "mutation createMigrationSource($name: String!, $url: String!, $ownerId: ID!, $type: MigrationSourceType!)";
+            var gql = "createMigrationSource(input: {name: $name, url: $url, ownerId: $ownerId, type: $type}) { migrationSource { id, name, url, type } }";
+
+            var payload = new
+            {
+                query = $"{query} {{ {gql} }}",
+                variables = new
+                {
+                    name = "Bitbucket Server Source",
+                    url = "https://not-used",
+                    ownerId = orgId,
+                    type = "BITBUCKET_SERVER"
+                },
+                operationName = "createMigrationSource"
+            };
+
+            var response = await _client.PostAsync(url, payload);
+            var data = JObject.Parse(response);
+
+            return (string)data["data"]["createMigrationSource"]["migrationSource"]["id"];
+        }
+
         public virtual async Task<string> CreateGhecMigrationSource(string orgId)
         {
             var url = $"{_apiUrl}/graphql";
@@ -268,6 +294,20 @@ mutation startRepositoryMigration(
             return (string)data["data"]["startRepositoryMigration"]["repositoryMigration"]["id"];
         }
 
+        public virtual async Task<string> StartBbsMigration(string migrationSourceId, string orgId, string repo, string targetToken, string archiveUrl)
+        {
+            return await StartMigration(
+                migrationSourceId,
+                "https://not-used",  // source repository URL
+                orgId,
+                repo,
+                "not-used",  // source access token
+                targetToken,
+                archiveUrl,
+                "https://not-used"  // metadata archive URL
+            );
+        }
+
         public virtual async Task<(string State, string RepositoryName, string FailureReason)> GetMigration(string migrationId)
         {
             var url = $"{_apiUrl}/graphql";

src/OctoshiftCLI.Tests/GithubApiTests.cs

@@ -472,6 +472,42 @@ public async Task CreateAdoMigrationSource_Uses_Ado_Server_Url()
             expectedMigrationSourceId.Should().Be(actualMigrationSourceId);
         }
 
+        [Fact]
+        public async Task CreateBbsMigrationSource_Returns_New_Migration_Source_Id()
+        {
+            // Arrange
+            const string url = "https://api.github.com/graphql";
+            const string orgId = "ORG_ID";
+            var payload =
+                "{\"query\":\"mutation createMigrationSource($name: String!, $url: String!, $ownerId: ID!, $type: MigrationSourceType!) " +
+                "{ createMigrationSource(input: {name: $name, url: $url, ownerId: $ownerId, type: $type}) { migrationSource { id, name, url, type } } }\"" +
+                $",\"variables\":{{\"name\":\"Bitbucket Server Source\",\"url\":\"https://not-used\",\"ownerId\":\"{orgId}\",\"type\":\"BITBUCKET_SERVER\"}},\"operationName\":\"createMigrationSource\"}}";
+            const string actualMigrationSourceId = "MS_kgC4NjFhOTVjOTc4ZTRhZjEwMDA5NjNhOTdm";
+            var response = $@"
+            {{
+                ""data"": {{
+                    ""createMigrationSource"": {{
+                        ""migrationSource"": {{
+                            ""id"": ""{actualMigrationSourceId}"",
+                            ""name"": ""Bitbucket Server Source"",
+                            ""url"": ""https://not-used"",
+                            ""type"": ""BITBUCKET_SERVER""
+                        }}
+                    }}
+                }}
+            }}";
+
+            _githubClientMock
+                .Setup(m => m.PostAsync(url, It.Is<object>(x => x.ToJson() == payload)))
+                .ReturnsAsync(response);
+
+            // Act
+            var expectedMigrationSourceId = await _githubApi.CreateBbsMigrationSource(orgId);
+
+            // Assert
+            expectedMigrationSourceId.Should().Be(actualMigrationSourceId);
+        }
+
         [Fact]
         public async Task CreateGhecMigrationSource_Returns_New_Migration_Source_Id()
         {
@@ -609,6 +645,108 @@ mutation startRepositoryMigration(
             expectedRepositoryMigrationId.Should().Be(actualRepositoryMigrationId);
         }
 
+        [Fact]
+        public async Task StartBbsMigration_Returns_New_Repository_Migration_Id()
+        {
+            // Arrange
+            const string migrationSourceId = "MIGRATION_SOURCE_ID";
+            const string orgId = "ORG_ID";
+            const string url = "https://api.github.com/graphql";
+            const string gitArchiveUrl = "GIT_ARCHIVE_URL";
+            const string targetToken = "TARGET_TOKEN";
+
+            const string unusedSourceRepoUrl = "https://not-used";
+            const string unusedSourceToken = "not-used";
+            const string unusedMetadataArchiveUrl = "https://not-used";
+
+            const string query = @"
+                mutation startRepositoryMigration(
+                    $sourceId: ID!,
+                    $ownerId: ID!,
+                    $sourceRepositoryUrl: URI!,
+                    $repositoryName: String!,
+                    $continueOnError: Boolean!,
+                    $gitArchiveUrl: String,
+                    $metadataArchiveUrl: String,
+                    $accessToken: String!,
+                    $githubPat: String,
+                    $skipReleases: Boolean)";
+            const string gql = @"
+                startRepositoryMigration(
+                    input: { 
+                        sourceId: $sourceId,
+                        ownerId: $ownerId,
+                        sourceRepositoryUrl: $sourceRepositoryUrl,
+                        repositoryName: $repositoryName,
+                        continueOnError: $continueOnError,
+                        gitArchiveUrl: $gitArchiveUrl,
+                        metadataArchiveUrl: $metadataArchiveUrl,
+                        accessToken: $accessToken,
+                        githubPat: $githubPat,
+                        skipReleases: $skipReleases
+                    }
+                ) {
+                    repositoryMigration {
+                        id,
+                        migrationSource {
+                            id,
+                            name,
+                            type
+                        },
+                        sourceUrl,
+                        state,
+                        failureReason
+                    }
+                  }";
+            var payload = new
+            {
+                query = $"{query} {{ {gql} }}",
+                variables = new
+                {
+                    sourceId = migrationSourceId,
+                    ownerId = orgId,
+                    sourceRepositoryUrl = unusedSourceRepoUrl,
+                    repositoryName = GITHUB_REPO,
+                    continueOnError = true,
+                    gitArchiveUrl,
+                    metadataArchiveUrl = unusedMetadataArchiveUrl,
+                    accessToken = unusedSourceToken,
+                    githubPat = targetToken,
+                    skipReleases = false
+                },
+                operationName = "startRepositoryMigration"
+            };
+            const string actualRepositoryMigrationId = "RM_kgC4NjFhNmE2NGU2ZWE1YTQwMDA5ODliZjhi";
+            var response = $@"
+            {{
+                ""data"": {{
+                    ""startRepositoryMigration"": {{
+                        ""repositoryMigration"": {{
+                            ""id"": ""{actualRepositoryMigrationId}"",
+                            ""migrationSource"": {{
+                                ""id"": ""MS_kgC4NjFhNmE2NDViNWZmOTEwMDA5MTZiMGQw"",
+                                ""name"": ""Azure Devops Source"",
+                                ""type"": ""AZURE_DEVOPS""
+                            }},
+                        ""sourceUrl"": ""https://dev.azure.com/github-inside-msft/Team-Demos/_git/Tiny"",
+                        ""state"": ""QUEUED"",
+                        ""failureReason"": """"
+                        }}
+                    }}
+                }}
+            }}";
+
+            _githubClientMock
+                .Setup(m => m.PostAsync(url, It.Is<object>(x => x.ToJson() == payload.ToJson())))
+                .ReturnsAsync(response);
+
+            // Act
+            var expectedRepositoryMigrationId = await _githubApi.StartBbsMigration(migrationSourceId, orgId, GITHUB_REPO, targetToken, gitArchiveUrl);
+
+            // Assert
+            expectedRepositoryMigrationId.Should().Be(actualRepositoryMigrationId);
+        }
+
         [Fact]
         public async Task StartMigration_Throws_When_GraphQL_Response_Has_Errors()
         {

src/OctoshiftCLI.Tests/OctoshiftCLI.Tests.csproj

@@ -10,6 +10,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\ado2gh\ado2gh.csproj" />
+    <ProjectReference Include="..\bbs2gh\bbs2gh.csproj" />
     <ProjectReference Include="..\gei\gei.csproj" />
     <PackageReference Include="FluentAssertions" Version="6.2.0" />
     <PackageReference Include="JunitXml.TestLogger" Version="3.0.98" />

src/OctoshiftCLI.Tests/bbs2gh/Commands/MigrateRepoCommandTests.cs

@@ -0,0 +1,144 @@
+using System.Threading.Tasks;
+using FluentAssertions;
+using Moq;
+using OctoshiftCLI.BbsToGithub;
+using OctoshiftCLI.BbsToGithub.Commands;
+using Xunit;
+
+namespace OctoshiftCLI.Tests.BbsToGithub.Commands
+{
+    public class MigrateRepoCommandTests
+    {
+        private readonly Mock<GithubApi> _mockGithubApi = TestHelpers.CreateMock<GithubApi>();
+        private readonly Mock<GithubApiFactory> _mockGithubApiFactory = TestHelpers.CreateMock<GithubApiFactory>();
+        private readonly Mock<OctoLogger> _mockOctoLogger = TestHelpers.CreateMock<OctoLogger>();
+        private readonly Mock<EnvironmentVariableProvider> _mockEnvironmentVariableProvider = TestHelpers.CreateMock<EnvironmentVariableProvider>();
+
+        private readonly MigrateRepoCommand _command;
+
+        private const string ARCHIVE_URL = "https://archive-url/bbs-archive.tar";
+        private const string GITHUB_ORG = "target-org";
+        private const string GITHUB_REPO = "target-repo";
+        private const string GITHUB_PAT = "github pat";
+
+        private const string GITHUB_ORG_ID = "github-org-id";
+        private const string MIGRATION_SOURCE_ID = "migration-source-id";
+        private const string MIGRATION_ID = "migration-id";
+
+        public MigrateRepoCommandTests()
+        {
+            _command = new MigrateRepoCommand(
+                _mockOctoLogger.Object,
+                _mockGithubApiFactory.Object,
+                _mockEnvironmentVariableProvider.Object
+            );
+        }
+
+        [Fact]
+        public void Should_Have_Options()
+        {
+            _command.Should().NotBeNull();
+            _command.Name.Should().Be("migrate-repo");
+            _command.Options.Count.Should().Be(6);
+
+            TestHelpers.VerifyCommandOption(_command.Options, "archive-url", true);
+            TestHelpers.VerifyCommandOption(_command.Options, "github-org", true);
+            TestHelpers.VerifyCommandOption(_command.Options, "github-repo", true);
+            TestHelpers.VerifyCommandOption(_command.Options, "github-pat", false);
+            TestHelpers.VerifyCommandOption(_command.Options, "wait", false);
+            TestHelpers.VerifyCommandOption(_command.Options, "verbose", false);
+        }
+
+        [Fact]
+        public async Task Happy_Path()
+        {
+            // Arrange
+            _mockEnvironmentVariableProvider.Setup(m => m.GithubPersonalAccessToken()).Returns(GITHUB_PAT);
+            _mockGithubApiFactory.Setup(m => m.Create(It.IsAny<string>(), It.IsAny<string>())).Returns(_mockGithubApi.Object);
+
+            _mockGithubApi.Setup(x => x.GetOrganizationId(GITHUB_ORG).Result).Returns(GITHUB_ORG_ID);
+            _mockGithubApi.Setup(x => x.CreateBbsMigrationSource(GITHUB_ORG_ID).Result).Returns(MIGRATION_SOURCE_ID);
+            _mockGithubApi
+                .Setup(x => x.StartBbsMigration(MIGRATION_SOURCE_ID, GITHUB_ORG_ID, GITHUB_REPO, GITHUB_PAT, ARCHIVE_URL).Result)
+                .Returns(MIGRATION_ID);
+
+            // Act
+            var args = new MigrateRepoCommandArgs
+            {
+                ArchiveUrl = ARCHIVE_URL,
+                GithubOrg = GITHUB_ORG,
+                GithubRepo = GITHUB_REPO
+            };
+            await _command.Invoke(args);
+
+            // Assert
+            _mockGithubApi.Verify(m => m.StartBbsMigration(
+                MIGRATION_SOURCE_ID,
+                GITHUB_ORG_ID,
+                GITHUB_REPO,
+                GITHUB_PAT,
+                ARCHIVE_URL
+            ));
+        }
+
+        [Fact]
+        public async Task Uses_GitHub_Pat_When_Provided_As_Option()
+        {
+            // Arrange
+            var githubPat = "specific github pat";
+
+            _mockGithubApiFactory.Setup(m => m.Create(It.IsAny<string>(), githubPat)).Returns(_mockGithubApi.Object);
+
+            _mockGithubApi.Setup(x => x.GetOrganizationId(GITHUB_ORG).Result).Returns(GITHUB_ORG_ID);
+            _mockGithubApi.Setup(x => x.CreateBbsMigrationSource(GITHUB_ORG_ID).Result).Returns(MIGRATION_SOURCE_ID);
+            _mockGithubApi
+                .Setup(x => x.StartBbsMigration(MIGRATION_SOURCE_ID, GITHUB_ORG_ID, GITHUB_REPO, GITHUB_PAT, ARCHIVE_URL).Result)
+                .Returns(MIGRATION_ID);
+
+            // Act
+            var args = new MigrateRepoCommandArgs
+            {
+                ArchiveUrl = ARCHIVE_URL,
+                GithubOrg = GITHUB_ORG,
+                GithubRepo = GITHUB_REPO,
+                GithubPat = githubPat
+            };
+            await _command.Invoke(args);
+
+            // Assert
+            _mockGithubApi.Verify(m => m.StartBbsMigration(
+                MIGRATION_SOURCE_ID,
+                GITHUB_ORG_ID,
+                GITHUB_REPO,
+                githubPat,
+                ARCHIVE_URL
+            ));
+        }
+
+        [Fact]
+        public async Task Skip_Migration_If_Target_Repo_Exists()
+        {
+            // Arrange
+            _mockEnvironmentVariableProvider.Setup(m => m.GithubPersonalAccessToken()).Returns(GITHUB_PAT);
+            _mockGithubApiFactory.Setup(m => m.Create(It.IsAny<string>(), It.IsAny<string>())).Returns(_mockGithubApi.Object);
+
+            _mockGithubApi.Setup(x => x.GetOrganizationId(GITHUB_ORG).Result).Returns(GITHUB_ORG_ID);
+            _mockGithubApi.Setup(x => x.CreateBbsMigrationSource(GITHUB_ORG_ID).Result).Returns(MIGRATION_SOURCE_ID);
+            _mockGithubApi
+                .Setup(x => x.StartBbsMigration(MIGRATION_SOURCE_ID, GITHUB_ORG_ID, GITHUB_REPO, GITHUB_PAT, ARCHIVE_URL).Result)
+                .Throws(new OctoshiftCliException($"A repository called {GITHUB_ORG}/{GITHUB_REPO} already exists"));
+
+            // Act
+            var args = new MigrateRepoCommandArgs
+            {
+                ArchiveUrl = ARCHIVE_URL,
+                GithubOrg = GITHUB_ORG,
+                GithubRepo = GITHUB_REPO
+            };
+            await _command.Invoke(args);
+
+            // Assert
+            _mockOctoLogger.Verify(m => m.LogWarning(It.IsAny<string>()), Times.Exactly(1));
+        }
+    }
+}