e2e: add initial bundle server clone test

Add a test and its corresponding step definitions verifying that a remote
repository initialized in a bundle server can be cloned with '--bundle-uri'
to download bundles.

Helped-by: Derrick Stolee <derrickstolee@github.com>
Signed-off-by: Victoria Dye <vdye@github.com>

Author: vdye

.gitignore

@@ -3,4 +3,5 @@
 /bin/
 /_dist/
 /_docs/
+/_test/
 node_modules/

test/e2e/features/basic.feature

@@ -2,3 +2,9 @@ Feature: Basic bundle server usage
 
   Background: The bundle web server is running
     Given the bundle web server was started at port 8080
+
+  Scenario: A user can clone with a bundle URI pointing to the bundle server
+    Given a remote repository 'https://github.com/vdye/asset-hash.git'
+    Given the bundle server has been initialized with the remote repo
+    When I clone from the remote repo with a bundle URI
+    Then bundles are downloaded and used

test/e2e/features/classes/bundleServer.ts

@@ -1,12 +1,20 @@
+import { randomBytes } from 'crypto'
 import * as child_process from 'child_process'
+import { RemoteRepo } from './remote'
 
 export class BundleServer {
+  private bundleServerCmd: string
   private bundleWebServerCmd: string
 
   // Web server
   private webServerProcess: child_process.ChildProcess | undefined
+  private bundleUriBase: string | undefined
 
-  constructor(bundleWebServerCmd: string) {
+  // Remote repo info (for now, only support one per test)
+  private route: string | undefined
+
+  constructor(bundleServerCmd: string, bundleWebServerCmd: string) {
+    this.bundleServerCmd = bundleServerCmd
     this.bundleWebServerCmd = bundleWebServerCmd
   }
 
@@ -15,6 +23,23 @@ export class BundleServer {
       throw new Error("Tried to start web server, but web server is already running")
     }
     this.webServerProcess = child_process.spawn(this.bundleWebServerCmd, ["--port", String(port)])
+    this.bundleUriBase = `http://localhost:${port}/`
+  }
+
+  init(remote: RemoteRepo): child_process.SpawnSyncReturns<Buffer> {
+    this.route = `e2e/${randomBytes(8).toString('hex')}`
+    return child_process.spawnSync(this.bundleServerCmd, ["init", remote.remoteUri, this.route])
+  }
+
+  bundleUri(): string {
+    if (!this.webServerProcess) {
+      throw new Error("Tried to get bundle URI before starting the web server")
+    }
+    if (!this.route) {
+      throw new Error("Tried to get bundle URI before running 'init'")
+    }
+
+    return this.bundleUriBase + this.route
   }
 
   cleanup(): void {
@@ -24,5 +49,10 @@ export class BundleServer {
         console.warn("Web server process was not successfully stopped")
       }
     }
+
+    // Delete the added route
+    if (this.route) {
+      child_process.spawnSync(this.bundleServerCmd, ["delete", this.route])
+    }
   }
 }

test/e2e/features/classes/remote.ts

@@ -0,0 +1,8 @@
+export class RemoteRepo {
+  remoteUri: string
+  root: string
+
+  constructor(url: string) {
+    this.remoteUri = url
+    this.root = ""
+  }

test/e2e/features/classes/repository.ts

@@ -0,0 +1,36 @@
+import * as child_process from 'child_process'
+import { RemoteRepo } from './remote'
+import * as utils from '../support/utils'
+
+export class ClonedRepository {
+  private initialized: boolean
+  private root: string
+  private remote: RemoteRepo | undefined
+
+  cloneResult: child_process.SpawnSyncReturns<Buffer>
+
+  constructor(remote: RemoteRepo, root: string, bundleUri?: string) {
+    this.initialized = false
+    this.remote = remote
+    this.root = root
+
+    // Clone the remote repository
+    let args = ["clone"]
+    if (bundleUri) {
+      args.push(`--bundle-uri=${bundleUri}`)
+    }
+    args.push(this.remote.remoteUri, this.root)
+
+    this.cloneResult = child_process.spawnSync("git", args)
+    if (!this.cloneResult.error) {
+      this.initialized = true
+    }
+  }
+
+  runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
+    if (!this.initialized) {
+      throw new Error("Repository is not initialized")
+    }
+    return utils.runGit("-C", this.root, ...args)
+  }
+}

test/e2e/features/step_definitions/bundleServer.ts

@@ -1,6 +1,14 @@
+import * as utils from '../support/utils'
 import { BundleServerWorld, } from '../support/world'
 import { Given } from '@cucumber/cucumber'
 
 Given('the bundle web server was started at port {int}', async function (this: BundleServerWorld, port: number) {
   this.bundleServer.startWebServer(port)
 })
+
+Given('the bundle server has been initialized with the remote repo', async function (this: BundleServerWorld) {
+  if (this.remote === undefined) {
+    throw new Error("Remote repository is not initialized")
+  }
+  utils.assertStatus(0, this.bundleServer.init(this.remote))
+})

test/e2e/features/step_definitions/remote.ts

@@ -0,0 +1,11 @@
+import { Given, } from '@cucumber/cucumber'
+import { RemoteRepo } from '../classes/remote'
+import { BundleServerWorld } from '../support/world'
+
+/**
+ * Steps relating to the setup of the remote repository users will clone from.
+ */
+
+Given('a remote repository {string}', async function (this: BundleServerWorld, url: string) {
+  this.remote = new RemoteRepo(url)
+})

test/e2e/features/step_definitions/repository.ts

@@ -0,0 +1,42 @@
+import * as assert from 'assert'
+import * as utils from '../support/utils'
+import { BundleServerWorld, User } from '../support/world'
+import { Given, When, Then } from '@cucumber/cucumber'
+
+/**
+ * Steps relating to the repository clones that users work with directly. Since
+ * these steps represent the actions a user takes, the majority of end-to-end
+ * test steps will live here.
+ */
+
+When('I clone from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
+  this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
+})
+
+Then('bundles are downloaded and used', async function (this: BundleServerWorld) {
+  const clonedRepo = this.getRepo(User.Me)
+
+  // Verify the clone executed as-expected
+  utils.assertStatus(0, clonedRepo.cloneResult, "git clone failed")
+
+  // Ensure warning wasn't thrown
+  clonedRepo.cloneResult.stderr.toString().split("\n").forEach(function (line) {
+    if (line.startsWith("warning: failed to download bundle from URI")) {
+      assert.fail(line)
+    }
+  })
+
+  // Make sure the config is set up properly
+  let result = clonedRepo.runGit("config", "--get", "fetch.bundleURI")
+  utils.assertStatus(0, result, "'fetch.bundleURI' is not set after clone")
+  const actualURI = result.stdout.toString().trim()
+  assert.strictEqual(actualURI, this.bundleServer.bundleUri())
+
+  result = clonedRepo.runGit("for-each-ref", "--format=%(refname)", "refs/bundles/*")
+  utils.assertStatus(0, result, "git for-each-ref failed")
+
+  const bundleRefs = result.stdout.toString().split("\n").filter(function(line) {
+    return line.trim() != ""
+  })
+  assert.strict(bundleRefs.length > 0, "No bundle refs found in the repo")
+})

test/e2e/features/support/utils.ts

@@ -1,4 +1,10 @@
 import * as path from 'path'
+import * as assert from 'assert'
+import * as child_process from 'child_process'
+
+export function runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
+  return child_process.spawnSync("git", args)
+}
 
 export function absPath(pathParam: string): string {
   // Convert a given path (either relative to 'test/e2e/' or absolute) to an
@@ -9,3 +15,11 @@ export function absPath(pathParam: string): string {
     return pathParam
   }
 }
+
+export function assertStatus(expectedStatusCode: number, result: child_process.SpawnSyncReturns<Buffer>, message?: string): void {
+  if (result.error) {
+    throw result.error
+  }
+  assert.strictEqual(result.status, expectedStatusCode,
+    `${message ?? "Invalid status code"}:\n\tstdout: ${result.stdout.toString()}\n\tstderr: ${result.stderr.toString()}`)
+}

test/e2e/features/support/world.ts

@@ -1,24 +1,71 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
+import { RemoteRepo } from '../classes/remote'
 import * as utils from './utils'
+import * as fs from 'fs'
+import * as path from 'path'
+import { ClonedRepository } from '../classes/repository'
 import { BundleServer } from '../classes/bundleServer'
 
+export enum User {
+  Me = 1,
+}
+
 interface BundleServerParameters {
+  bundleServerCommand: string
   bundleWebServerCommand: string
+  trashDirectoryBase: string
 }
 
 export class BundleServerWorld extends World<BundleServerParameters> {
+  // Internal variables
+  trashDirectory: string
+
   // Bundle server
   bundleServer: BundleServer
+  remote: RemoteRepo | undefined
+
+  // Users
+  repoMap: Map<User, ClonedRepository>
 
   constructor(options: IWorldOptions<BundleServerParameters>) {
     super(options)
 
+    this.repoMap = new Map<User, ClonedRepository>()
+
+    // Set up the trash directory
+    this.trashDirectory = path.join(utils.absPath(this.parameters.trashDirectoryBase), randomUUID())
+    fs.mkdirSync(this.trashDirectory, { recursive: true });
+
     // Set up the bundle server
-    this.bundleServer = new BundleServer(utils.absPath(this.parameters.bundleWebServerCommand))
+    this.bundleServer = new BundleServer(utils.absPath(this.parameters.bundleServerCommand),
+      utils.absPath(this.parameters.bundleWebServerCommand))
+  }
+
+  cloneRepositoryFor(user: User, bundleUri?: string): void {
+    if (!this.remote) {
+      throw new Error("Remote repository is not initialized")
+    }
+
+    const repoRoot = `${this.trashDirectory}/${User[user]}`
+    this.repoMap.set(user, new ClonedRepository(this.remote, repoRoot, bundleUri))
+  }
+
+  getRepo(user: User): ClonedRepository {
+    const repo = this.repoMap.get(user)
+    if (!repo) {
+      throw new Error("Cloned repository has not been initialized")
+    }
+
+    return repo
+  }
+
   }
 
   cleanup(): void {
     this.bundleServer.cleanup()
+
+    // Delete the trash directory
+    fs.rmSync(this.trashDirectory, { recursive: true })
   }
 }