e2e: even more WIP

Signed-off-by: Victoria Dye <[email protected]>

Author: vdye

test/e2e/features/basic.feature

@@ -3,28 +3,32 @@ Feature: Basic bundle server usage
   Background: The bundle web server is running
     Given the bundle web server was started at port 8080
 
-  Scenario: First-time bundle server setup
+  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
 
-  # 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: A user can fetch with a bundle server that's behind and get all updates
+    Given a new remote repository with main branch 'main'
+    Given another user pushed 10 commits to 'main'
+    Given the bundle server has been initialized with the remote repo
+    Given I cloned from the remote repo with a bundle URI
+    Given another user pushed 2 commits to 'main'
+    When I fetch from the remote
+    Then I am up-to-date with 'main'
+    Then my repo's bundles are not 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: A user will fetch incremental bundles to stay up-to-date
+    Given a new remote repository with main branch 'main'
+    Given another user pushed 10 commits to 'main'
+    Given the bundle server has been initialized with the remote repo
+    Given I cloned from the remote repo with a bundle URI
+    Given another user pushed 2 commits to 'main'
+    Given the bundle server was updated for the remote repo
+    When I fetch from the remote
+    Then I am up-to-date with 'main'
+    Then my repo's bundles are up-to-date with 'main'
 
   # Scenario: Bundle with a force-push
   #   Given a remote repository with 10 commits to 'main'

test/e2e/features/support/bundleServer.ts renamed to test/e2e/features/classes/bundleServer.ts

@@ -19,7 +19,7 @@ export class BundleServer {
   }
 
   startWebServer(port: number): void {
-    if (this.webServerProcess !== undefined) {
+    if (this.webServerProcess) {
       throw new Error("Tried to start web server, but web server is already running")
     }
     this.webServerProcess = child_process.spawn(this.bundleWebServerCmd, ["--port", String(port)])
@@ -31,11 +31,18 @@ export class BundleServer {
     return child_process.spawnSync(this.bundleServerCmd, ["init", remote.remoteUri, this.route])
   }
 
+  update(): child_process.SpawnSyncReturns<Buffer> {
+    if (!this.route) {
+      throw new Error("Tried to update server before running 'init'")
+    }
+    return child_process.spawnSync(this.bundleServerCmd, ["update", this.route])
+  }
+
   bundleUri(): string {
-    if (this.webServerProcess === undefined) {
+    if (!this.webServerProcess) {
       throw new Error("Tried to get bundle URI before starting the web server")
     }
-    if (this.route === undefined) {
+    if (!this.route) {
       throw new Error("Tried to get bundle URI before running 'init'")
     }
 
@@ -51,7 +58,7 @@ export class BundleServer {
     }
 
     // Delete the added route
-    if (this.route !== undefined) {
+    if (this.route) {
       child_process.spawnSync(this.bundleServerCmd, ["delete", this.route])
     }
   }

test/e2e/features/classes/remote.ts

@@ -0,0 +1,43 @@
+import * as path from 'path'
+import * as utils from '../support/utils'
+import * as child_process from 'child_process'
+
+export class RemoteRepo {
+  isLocal: boolean
+  remoteUri: string
+  root: string
+
+  constructor(isLocal: boolean, urlOrPath: string, mainBranch?: string) {
+    this.isLocal = isLocal
+    if (!this.isLocal) {
+      // Not a bare repo on the filesystem
+      this.remoteUri = urlOrPath
+      this.root = ""
+    } else {
+      // Bare repo on the filesystem - need to initialize
+      if (urlOrPath.startsWith("file://")) {
+        this.remoteUri = urlOrPath
+        this.root = urlOrPath.substring(7)
+      } else if (path.isAbsolute(urlOrPath)) {
+        this.remoteUri = `file://${urlOrPath}`
+        this.root = urlOrPath
+      } else {
+        throw new Error("'urlOrPath' must be a 'file://' URL or absolute path")
+      }
+
+      utils.assertStatus(0, utils.runGit("init", "--bare", this.root))
+      if (mainBranch) {
+        utils.assertStatus(0,  utils.runGit("-C", this.root, "symbolic-ref", "HEAD", `refs/heads/${mainBranch}`))
+      }
+    }
+  }
+
+  getBranchTipOid(branch: string): string {
+    if (!this.isLocal) {
+      throw new Error("Logged branch tips are only available for local custom remotes")
+    }
+    const result = child_process.spawnSync("cat", [`refs/heads/${branch}`], { shell: true, cwd: this.root })
+    utils.assertStatus(0, result)
+    return result.stdout.toString().trim()
+  }
+}

test/e2e/features/support/repository.ts renamed to test/e2e/features/classes/repository.ts

@@ -1,5 +1,6 @@
 import * as child_process from 'child_process'
 import { RemoteRepo } from './remote'
+import * as utils from '../support/utils'
 
 export class ClonedRepository {
   private initialized: boolean
@@ -26,11 +27,17 @@ export class ClonedRepository {
     }
   }
 
-  runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
+  runShell(command: string, ...args: string[]): child_process.SpawnSyncReturns<Buffer> {
     if (!this.initialized) {
       throw new Error("Repository is not initialized")
     }
+    return child_process.spawnSync(command, args, { shell: true, cwd: this.root })
+  }
 
-    return child_process.spawnSync("git", ["-C", this.root].concat(args))
+  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

@@ -0,0 +1,18 @@
+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))
+})
+
+Given('the bundle server was updated for the remote repo', async function(this: BundleServerWorld) {
+  utils.assertStatus(0, this.bundleServer.update())
+})

test/e2e/features/step_definitions/remote.ts

@@ -0,0 +1,16 @@
+import { Given, } from '@cucumber/cucumber'
+import { RemoteRepo } from '../classes/remote'
+import { BundleServerWorld, } from '../support/world'
+import * as path from 'path'
+
+/**
+ * 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(false, url)
+})
+
+Given('a new remote repository with main branch {string}', async function(this: BundleServerWorld, mainBranch: string) {
+  this.remote = new RemoteRepo(true, path.join(this.trashDirectory, "server"), mainBranch)
+})

test/e2e/features/step_definitions/repository.ts

@@ -0,0 +1,103 @@
+import * as assert from 'assert'
+import * as utils from '../support/utils'
+import { randomBytes } from 'crypto'
+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.
+ */
+
+Given('another user pushed {int} commits to {string}', async function(this: BundleServerWorld, commitNum: number, branch: string) {
+  if (this.remote && !this.remote.isLocal) {
+    throw new Error("Remote is not initialized or does not allow pushes")
+  }
+
+  const user = User.Another
+  if (!this.repoMap.has(user)) {
+    this.cloneRepositoryFor(user)
+    utils.assertStatus(0, this.getRepo(user).cloneResult)
+  }
+  const clonedRepo = this.getRepo(user)
+
+  // TODO: figure out a better way to check whether the repo is empty
+  if (clonedRepo.runGit("show").status != 0) {
+    // Repo is empty, so make sure we're on the right branch
+    clonedRepo.runGit("branch", "-m", branch)
+  } else {
+    clonedRepo.runGit("switch", branch)
+    clonedRepo.runGit("pull", "origin", branch)
+  }
+
+  for (let i = 0; i < commitNum; i++) {
+    utils.assertStatus(0, clonedRepo.runShell(`echo ${randomBytes(16).toString('hex')} >README.md`))
+    utils.assertStatus(0, clonedRepo.runGit("add", "README.md"))
+    utils.assertStatus(0, clonedRepo.runGit("commit", "-m", `test ${i+1}`))
+  }
+  utils.assertStatus(0, clonedRepo.runGit("push", "origin", branch))
+})
+
+Given('I cloned from the remote repo with a bundle URI', async function(this: BundleServerWorld) {
+  const user = User.Me
+  this.cloneRepositoryFor(user, this.bundleServer.bundleUri())
+  utils.assertStatus(0, this.getRepo(user).cloneResult)
+})
+
+When('I clone from the remote repo with a bundle URI', async function(this: BundleServerWorld) {
+  this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
+})
+
+When('I fetch from the remote', async function(this: BundleServerWorld) {
+  const clonedRepo = this.getRepo(User.Me)
+  utils.assertStatus(0, clonedRepo.runGit("fetch", "origin"))
+})
+
+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)
+    }
+  })
+
+  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 = result.stdout.toString().split("\n").filter(function(line) {
+    return bundleRefRegex.test(line)
+  })
+  assert.strict(bundleRefs.length > 0, "No bundle refs found in the repo")
+})
+
+Then('I am up-to-date with {string}', async function(this: BundleServerWorld, branch: string) {
+  const clonedRepo = this.getRepo(User.Me)
+  const result = clonedRepo.runGit("rev-parse", `refs/remotes/origin/${branch}`)
+  utils.assertStatus(0, result)
+  const actualOid = result.stdout.toString().trim()
+  const expectedOid = this.remote?.getBranchTipOid(branch)
+  assert.strictEqual(actualOid, expectedOid, `branch '${branch}' is not up-to-date`)
+})
+
+Then('my repo\'s bundles {boolean} up-to-date with {string}',
+  async function(this: BundleServerWorld, expectedUpToDate: boolean, branch: string) {
+    const clonedRepo = this.getRepo(User.Me)
+    const result = clonedRepo.runGit("rev-parse", `refs/bundles/${branch}`)
+    utils.assertStatus(0, result)
+    const actualOid = result.stdout.toString().trim()
+    const expectedOid = this.remote?.getBranchTipOid(branch)
+
+    if (expectedUpToDate) {
+      assert.strictEqual(actualOid, expectedOid, `bundle ref for '${branch}' is not up-to-date`)
+    } else {
+      assert.notStrictEqual(actualOid, expectedOid, `bundle ref for '${branch}' is up-to-date, but should not be`)
+    }
+  }
+)

test/e2e/features/step_definitions/shared.ts

@@ -0,0 +1,10 @@
+import { BundleServerWorld } from '../support/world'
+import { After } from '@cucumber/cucumber'
+
+/**
+ * Steps handling operations that are common across tests.
+ */
+
+After(function (this: BundleServerWorld) {
+  this.cleanup()
+});

test/e2e/features/step_definitions/steps.ts

@@ -0,0 +1,7 @@
+import { defineParameterType } from '@cucumber/cucumber'
+
+defineParameterType({
+  name: 'boolean',
+  regexp: /are|are not/,
+  transformer: s => s == "are"
+})