e2e: add tests updating the remote & bundle server

Add scenarios to the end-to-end tests involving updates to the remote and/or
bundle server. As part of this update, add a custom Cucumber expression for
matching "are/are not" to a boolean.

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

Author: vdye

test/e2e/cucumber.js

@@ -8,7 +8,9 @@ module.exports = {
       snippetInterface: 'async-await'
     },
     worldParameters: {
+      bundleServerCommand: '../../bin/git-bundle-server',
       bundleWebServerCommand: '../../bin/git-bundle-web-server',
+      trashDirectoryBase: '../../_test/e2e'
     }
   }
 }

test/e2e/features/basic.feature

@@ -8,3 +8,35 @@ Feature: Basic bundle server usage
     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: 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: 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: A user can fetch force-pushed refs from the bundle server
+    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 removed 2 commits and added 4 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'

test/e2e/features/classes/bundleServer.ts

@@ -31,6 +31,13 @@ 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) {
       throw new Error("Tried to get bundle URI before starting the web server")

test/e2e/features/classes/remote.ts

@@ -1,8 +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(url: string) {
-    this.remoteUri = url
-    this.root = ""
+  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/classes/repository.ts

@@ -27,6 +27,13 @@ export class ClonedRepository {
     }
   }
 
+  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 })
+  }
+
   runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
     if (!this.initialized) {
       throw new Error("Repository is not initialized")

test/e2e/features/step_definitions/bundleServer.ts

@@ -12,3 +12,7 @@ Given('the bundle server has been initialized with the remote repo', async funct
   }
   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

@@ -1,11 +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(url)
+  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

@@ -1,5 +1,6 @@
 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'
 
@@ -9,10 +10,51 @@ import { Given, When, Then } from '@cucumber/cucumber'
  * test steps will live here.
  */
 
+Given('another user pushed {int} commits to {string}', async function (this: BundleServerWorld, commitNum: number, branch: string) {
+  const clonedRepo = this.getRepoAtBranch(User.Another, 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('another user removed {int} commits and added {int} commits to {string}',
+  async function (this: BundleServerWorld, removeCommits: number, addCommits: number, branch: string) {
+    const clonedRepo = this.getRepoAtBranch(User.Another, branch)
+
+    // First, reset
+    utils.assertStatus(0, clonedRepo.runGit("reset", "--hard", `HEAD~${removeCommits}`))
+
+    // Then, add new commits
+    for (let i = 0; i < addCommits; 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}`))
+    }
+
+    // Finally, force push
+    utils.assertStatus(0, clonedRepo.runGit("push", "-f", "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)
 
@@ -40,3 +82,28 @@ Then('bundles are downloaded and used', async function (this: BundleServerWorld)
   })
   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/support/expressions.ts

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

test/e2e/features/support/world.ts

@@ -1,4 +1,5 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
+import { randomUUID } from 'crypto'
 import { RemoteRepo } from '../classes/remote'
 import * as utils from './utils'
 import * as fs from 'fs'
@@ -8,6 +9,7 @@ import { BundleServer } from '../classes/bundleServer'
 
 export enum User {
   Me = 1,
+  Another,
 }
 
 interface BundleServerParameters {
@@ -59,6 +61,28 @@ export class BundleServerWorld extends World<BundleServerParameters> {
     return repo
   }
 
+  getRepoAtBranch(user: User, branch: string): ClonedRepository {
+    if (this.remote && !this.remote.isLocal) {
+      throw new Error("Remote is not initialized or does not allow pushes")
+    }
+
+    if (!this.repoMap.has(user)) {
+      this.cloneRepositoryFor(user)
+      utils.assertStatus(0, this.getRepo(user).cloneResult)
+    }
+
+    const clonedRepo = this.getRepo(user)
+
+    const result = clonedRepo.runGit("rev-list", "--all", "-n", "1")
+    if (result.stdout.toString().trim() == "") {
+      // Repo is empty, so make sure we're on the right branch
+      utils.assertStatus(0, clonedRepo.runGit("branch", "-m", branch))
+    } else {
+      utils.assertStatus(0, clonedRepo.runGit("switch", branch))
+      utils.assertStatus(0, clonedRepo.runGit("pull", "origin", branch))
+    }
+
+    return clonedRepo
   }
 
   cleanup(): void {