e2e: more WIP

vdye · vdye · commit 2b2ed70391c3 · 2023-03-15T11:12:24.000-07:00
Signed-off-by: Victoria Dye &lt;vdye@github.com&gt;
diff --git a/test/e2e/features/basic.feature b/test/e2e/features/basic.feature
@@ -1,9 +1,36 @@
 Feature: Basic bundle server usage
 
   Background: The bundle web server is running
-    Given the bundle web server is running at port 8080
+    Given the bundle web server was started at port 8080
 
   Scenario: First-time bundle server setup
-    Given the bundle server has been initialized with 'https://github.com/vdye/asset-hash.git'
-    When I clone from 'https://github.com/vdye/asset-hash.git' with a bundle URI
-    Then bundles are downloaded and used
+    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
+
+  # Scenario: Bundle server is behind remote
+  #   Given a new remote repository with main branch 'main'
+  #   Given the bundle server has been initialized with the remote repo
+  #   Given I clone from the remote repo with a bundle URI
+  #   Given another developer pushes 2 commits to 'main'
+  #   When I fetch from the remote
+  #   Then I am up-to-date with 'main'
+
+  # Scenario: Fetch an incremental bundle
+  #   Given a remote repository with 10 commits to 'main'
+  #   Given the bundle server has been initialized with the remote repo
+  #   Given I clone from the local repo with a bundle URI
+  #   Given another developer pushes 2 commits to 'main'
+  #   Given the bundle server is updated for the local repo
+  #   When I fetch from the remote
+  #   Then I am up-to-date with 'main'
+
+  # Scenario: Bundle with a force-push
+  #   Given a remote repository with 10 commits to 'main'
+  #   Given the bundle server has been initialized with the local repo
+  #   Given I clone from the local repo with a bundle URI
+  #   Given another developer removes 2 commits and adds 4 commits to 'main'
+  #   Given the bundle server is updated for the local repo
+  #   When I fetch from the remote
+  #   Then I am up-to-date with 'main'
diff --git a/test/e2e/features/step_definitions/steps.ts b/test/e2e/features/step_definitions/steps.ts
@@ -1,42 +1,45 @@
 import * as assert from 'assert'
-import { BundleServerWorld } from '../support/world'
+import { BundleServerWorld, User } from '../support/world'
+import { RemoteRepo } from '../support/remote'
 import { Given, When, Then, After } from '@cucumber/cucumber'
 
-Given('the bundle web server is running at port {int}', async function(this: BundleServerWorld, port: number) {
-  this.startWebServer(port)
+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 {string}', async function(this: BundleServerWorld, url: string) {
-  const result = this.bundleServerInit(url)
-  assert.strictEqual(result.status, 0, "git-bundle-server init failed")
+Given('a remote repository {string}', async function(this: BundleServerWorld, url: string) {
+  this.remote = new RemoteRepo(false, url)
 })
 
-When('I clone from {string} with a bundle URI', async function(this: BundleServerWorld, url: string) {
-  this.cloneWithBundleUri(url)
+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")
+  }
+  this.bundleServer.init(this.remote)
+})
+
+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) {
-  // Verify the command executed as-expected
-  if (this.cloneResult === undefined) {
-    throw new Error("Tried to access clone result before clone")
-  }
+  const clonedRepo = this.getRepo(User.Me)
 
-  // Exit code
-  assert.strictEqual(this.cloneResult.status, 0, "git clone failed")
+  // Verify the clone executed as-expected
+  assert.strictEqual(clonedRepo.cloneResult.status, 0, "git clone failed")
 
   // Ensure warning wasn't thrown
-  this.cloneResult.stderr.toString().split("\n").forEach(function(line) {
+  clonedRepo.cloneResult.stderr.toString().split("\n").forEach(function(line) {
     if (line.startsWith("warning: failed to download bundle from URI")) {
       assert.fail(line)
     }
   })
 
-  // TODO: verify results of 'for-each-ref'
-  const result = this.runGitInLocalRepo("for-each-ref", "--format=%(refname)")
+  const result = clonedRepo.runGit("for-each-ref", "--format=%(refname)")
   assert.strictEqual(result.status, 0, "git for-each-ref failed")
 
   const bundleRefRegex = new RegExp('^refs/bundles/.*$')
-  const bundleRefs = this.cloneResult.stdout.toString().split("\n").filter(function(line) {
+  const bundleRefs = result.stdout.toString().split("\n").filter(function(line) {
     return bundleRefRegex.test(line)
   })
   assert.strict(bundleRefs.length > 0, "No bundle refs found in the repo")
diff --git a/test/e2e/features/support/bundleServer.ts b/test/e2e/features/support/bundleServer.ts
@@ -0,0 +1,58 @@
+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
+
+  // 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
+  }
+
+  startWebServer(port: number): void {
+    if (this.webServerProcess !== undefined) {
+      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 === undefined) {
+      throw new Error("Tried to get bundle URI before starting the web server")
+    }
+    if (this.route === undefined) {
+      throw new Error("Tried to get bundle URI before running 'init'")
+    }
+
+    return this.bundleUriBase + this.route
+  }
+
+  cleanup(): void {
+    if (this.webServerProcess) {
+      const killed = this.webServerProcess.kill('SIGINT')
+      if (!killed) {
+        console.warn("Web server process was not successfully stopped")
+      }
+    }
+
+    // Delete the added route
+    if (this.route !== undefined) {
+      child_process.spawnSync(this.bundleServerCmd, ["delete", this.route])
+    }
+  }
+}
diff --git a/test/e2e/features/support/remote.ts b/test/e2e/features/support/remote.ts
@@ -0,0 +1,9 @@
+export class RemoteRepo {
+  remoteUri: string
+  private isLocal: boolean
+
+  constructor(isLocal: boolean, uri: string) {
+    this.remoteUri = uri
+    this.isLocal = isLocal
+  }
+}
diff --git a/test/e2e/features/support/repository.ts b/test/e2e/features/support/repository.ts
@@ -0,0 +1,36 @@
+import * as child_process from 'child_process'
+import { RemoteRepo } from './remote'
+
+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 child_process.spawnSync("git", ["-C", this.root].concat(args))
+  }
+}
diff --git a/test/e2e/features/support/utils.ts b/test/e2e/features/support/utils.ts
@@ -0,0 +1,10 @@
+import * as path from 'path'
+
+export function absPath(pathParam: string): string {
+  // Convert a path (possibly relative to 'test/e2e/') to an absolute path
+  if (!path.isAbsolute(pathParam)) {
+    return path.resolve(__dirname, "../..", pathParam)
+  } else {
+    return pathParam
+  }
+}
diff --git a/test/e2e/features/support/world.ts b/test/e2e/features/support/world.ts
@@ -1,8 +1,16 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
-import { randomUUID, randomBytes } from 'crypto'
-import * as child_process from 'child_process'
+import { randomUUID } from 'crypto'
+import { RemoteRepo } from './remote'
+import { absPath } from './utils'
 import * as fs from 'fs'
 import * as path from 'path'
+import { ClonedRepository } from './repository'
+import { BundleServer } from './bundleServer'
+
+export enum User {
+  Me = 1,
+  Another,
+}
 
 interface BundleServerParameters {
   bundleServerCommand: string
@@ -13,78 +21,48 @@ interface BundleServerParameters {
 export class BundleServerWorld extends World<BundleServerParameters> {
   // Internal variables
   private trashDirectory: string
-  private webServer: child_process.ChildProcess | undefined
-  private bundleUriBase: string | undefined
-  private route: string | undefined
 
-  cloneResult: child_process.SpawnSyncReturns<Buffer> | undefined
+  // Bundle server
+  bundleServer: BundleServer
+  remote: RemoteRepo | undefined
 
+  // Users
+  private repoMap: Map<User, ClonedRepository>
 
   constructor(options: IWorldOptions<BundleServerParameters>) {
     super(options)
 
+    this.repoMap = new Map<User, ClonedRepository>()
+
     // Set up the trash directory
-    this.trashDirectory = this.pathParamToAbsolute(
-      path.join(this.parameters.trashDirectoryBase, randomUUID())
-    )
+    this.trashDirectory = path.join(absPath(this.parameters.trashDirectoryBase), randomUUID())
     fs.mkdirSync(this.trashDirectory, { recursive: true });
-  }
 
-  pathParamToAbsolute(relPath: string): string {
-    let absPath = this.parameters.bundleWebServerCommand
-    if (!path.isAbsolute(absPath)) {
-      // Assume relative path is relative to 'test/e2e'
-      absPath = path.resolve(__dirname, "../..", relPath)
-    }
-    return absPath
+    // Set up the bundle server
+    this.bundleServer = new BundleServer(absPath(this.parameters.bundleServerCommand),
+                                         absPath(this.parameters.bundleWebServerCommand))
   }
 
-  startWebServer(port: number): void {
-    if (this.webServer !== undefined) {
-      throw new Error("Tried to start web server, but web server is already running")
+  cloneRepositoryFor(user: User, bundleUri?: string): void {
+    if (this.remote === undefined) {
+      throw new Error("Remote repository is not initialized")
     }
 
-    const webServerCmd = this.pathParamToAbsolute(this.parameters.bundleWebServerCommand)
-    this.webServer = child_process.spawn(webServerCmd, ["--port", String(port)])
-    this.bundleUriBase = `http://localhost:${port}/`
-  }
-
-  bundleServerInit(url: string): child_process.SpawnSyncReturns<Buffer> {
-    const serverCliCmd = this.pathParamToAbsolute(this.parameters.bundleServerCommand)
-    this.route = `e2e/${randomBytes(8).toString('hex')}`
-    return child_process.spawnSync(serverCliCmd, ["init", url, this.route])
+    const repoRoot = `${this.trashDirectory}/${User[user]}`
+    this.repoMap.set(user, new ClonedRepository(this.remote, repoRoot,  bundleUri))
   }
 
-  cloneWithBundleUri(url: string): void {
-    if (this.route === undefined || this.bundleUriBase === undefined) {
-      throw new Error("Bundle URI is not initialized")
+  getRepo(user: User): ClonedRepository {
+    const repo = this.repoMap.get(user)
+    if (repo === undefined) {
+      throw new Error("Cloned repository has not been initialized")
     }
 
-    this.cloneResult = child_process.spawnSync("git",
-      ["clone", `--bundle-uri=${this.bundleUriBase}/${this.route}/`, url, this.trashDirectory]
-    )
-  }
-
-  runGitInLocalRepo(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
-    return child_process.spawnSync("git",
-      ["-C", this.trashDirectory].concat(args)
-    )
+    return repo
   }
 
   cleanup(): void {
-    // Stop the web server
-    if (this.webServer !== undefined) {
-      const killed = this.webServer.kill('SIGINT')
-      if (!killed) {
-        console.warn("Web server process was not successfully stopped")
-      }
-    }
-
-    // Delete the added route
-    if (this.route !== undefined) {
-      const serverCliCmd = this.pathParamToAbsolute(this.parameters.bundleServerCommand)
-      child_process.spawnSync(serverCliCmd, ["delete", this.route])
-    }
+    this.bundleServer.cleanup()
 
     // Delete the trash directory
     fs.rmSync(this.trashDirectory, { recursive: true })
