integration tests: commands

Add integration tests for the following commands, which represent core
bundle server functionality:

1. init
2. delete
3. update
4. start
5. stop

Signed-off-by: Lessley Dennington <[email protected]>

Author: ldennington

test/e2e/features/step_definitions/bundleServer.ts

@@ -6,7 +6,7 @@ Given('the bundle server has been initialized with the remote repo', async funct
   if (this.remote === undefined) {
     throw new Error("Remote repository is not initialized")
   }
-  utils.assertStatus(0, this.bundleServer.init(this.remote))
+  utils.assertStatus(0, this.bundleServer.init(this.remote, 'e2e'))
 })
 
 Given('the bundle server was updated for the remote repo', async function (this: EndToEndBundleServerWorld) {

test/integration/cucumber.js

@@ -0,0 +1,28 @@
+const common = {
+  requireModule: ['ts-node/register'],
+  require: [`${__dirname}/features/**/*.ts`, `${__dirname}/../shared/features/**/*.ts`],
+  publishQuiet: true,
+  format: ['progress'],
+  formatOptions: {
+    snippetInterface: 'async-await'
+  },
+  worldParameters: {
+    bundleServerCommand: `${__dirname}/../../bin/git-bundle-server`,
+    bundleWebServerCommand: `${__dirname}/../../bin/git-bundle-web-server`,
+    trashDirectoryBase: `${__dirname}/../../_test/integration`
+  }
+}
+
+module.exports = {
+  default: {
+    ...common,
+  },
+  offline: {
+    ...common,
+    tags: 'not @online',
+  },
+  ci: {
+    ...common,
+    tags: 'not @daemon',
+  },
+}

test/integration/features/command.feature

@@ -0,0 +1,42 @@
+Feature: Bundle server command tests
+
+  Background: The bundle web server is running
+    Given the bundle web server was started at port 8080
+
+  @online
+  Scenario: The init command initializes a bundle server repository
+    Given no bundle server repository exists at route 'integration/asset-hash'
+    When I run the bundle server CLI command 'init https://github.com/vdye/asset-hash.git integration/asset-hash'
+    Then a bundle server repository exists at route 'integration/asset-hash'
+
+  @online
+  Scenario: The delete command removes route configuration and repository data
+    Given a remote repository 'https://github.com/vdye/asset-hash.git'
+    Given a bundle server repository is created at route 'integration/asset-hash' for the remote
+    When I run the bundle server CLI command 'delete integration/asset-hash'
+    Then the route configuration and repository data at 'integration/asset-hash' are removed
+
+  Scenario: The update command fetches the latest remote content and updates the bundle list
+    Given no bundle server repository exists at route 'integration/bundle'
+    Given a new remote repository with main branch 'main'
+    Given the remote is cloned
+    Given 5 commits are pushed to the remote branch 'main'
+    Given a bundle server repository is created at route 'integration/bundle' for the remote
+    Given 2 commits are pushed to the remote branch 'main'
+    When I run the bundle server CLI command 'update integration/bundle'
+    Then the bundles are fetched and the bundle list is updated
+
+  Scenario: The stop command updates the routes file
+    Given no bundle server repository exists at route 'integration/stop'
+    Given a new remote repository with main branch 'main'
+    Given a bundle server repository is created at route 'integration/stop' for the remote
+    When I run the bundle server CLI command 'stop integration/stop'
+    Then the route is removed from the routes file
+
+  Scenario: The start command updates the routes file
+    Given no bundle server repository exists at route 'integration/start'
+    Given a new remote repository with main branch 'main'
+    Given a bundle server repository is created at route 'integration/start' for the remote
+    When I run the bundle server CLI command 'stop integration/start'
+    When I run the bundle server CLI command 'start integration/start'
+    Then the route exists in the routes file

test/integration/features/step_definitions/bundleServer.ts

@@ -0,0 +1,73 @@
+import * as assert from 'assert'
+import { IntegrationBundleServerWorld } from '../support/world'
+import { Given, Then } from '@cucumber/cucumber'
+import * as utils from '../../../shared/support/utils'
+import * as fs from 'fs'
+
+Given('a bundle server repository is created at route {string} for the remote', async function (this: IntegrationBundleServerWorld, route: string) {
+  if (!this.remote) {
+    throw new Error("Remote has not been initialized")
+  }
+  this.bundleServer.init(this.remote, 'integration', route)
+})
+
+Given('no bundle server repository exists at route {string}', async function (this: IntegrationBundleServerWorld, route: string) {
+  var repoPath = utils.repoRoot(route)
+  if (fs.existsSync(repoPath)) {
+    throw new Error(`Repo already exists at ${repoPath}`)
+  }
+})
+
+Then('a bundle server repository exists at route {string}', async function (this: IntegrationBundleServerWorld, route: string) {
+  var repoRoot = utils.repoRoot(route)
+  assert.equal(fs.existsSync(repoRoot), true)
+  assert.equal(fs.existsSync(`${repoRoot}/.git`), false)
+  assert.equal(fs.existsSync(`${repoRoot}/HEAD`), true)
+  assert.equal(fs.existsSync(`${repoRoot}/bundle-list.json`), true)
+
+  // Set route for cleanup
+  this.bundleServer.route = route
+})
+
+Then('the route configuration and repository data at {string} are removed', async function (this: IntegrationBundleServerWorld, route: string) {
+  var repoRoot = utils.repoRoot(route)
+  var routeData = fs.readFileSync(utils.routesPath())
+
+  assert.equal(fs.existsSync(repoRoot), false)
+  assert.equal(routeData.includes(route), false)
+
+  // Reset route to be ignored in cleanup
+  this.bundleServer.route = undefined
+})
+
+Then('the bundles are fetched and the bundle list is updated', async function (this: IntegrationBundleServerWorld) {
+  assert.strictEqual(this.commandResult?.stdout.toString()
+    .includes('Updating bundle list\n' +
+              'Writing updated bundle list\n' +
+              'Update complete'), true)
+
+  if (this.bundleServer.initialBundleCount) {
+    const currentBundleCount = this.bundleServer.getBundleCount()
+    assert.strictEqual(currentBundleCount > this.bundleServer.initialBundleCount, true)
+  } else {
+    throw new Error("Bundle server not initialized")
+  }
+})
+
+Then('the route is removed from the routes file', async function (this: IntegrationBundleServerWorld) {
+  if (this.bundleServer.route) {
+    var routesPath = utils.routesPath()
+    var data = fs.readFileSync(routesPath);
+    assert.strictEqual(data.includes(this.bundleServer.route), false)
+  }
+})
+
+Then('the route exists in the routes file', async function (this: IntegrationBundleServerWorld) {
+  if (this.bundleServer.route) {
+    var routesPath = utils.routesPath()
+    var data = fs.readFileSync(routesPath);
+    assert.strictEqual(data.includes(this.bundleServer.route), true)
+  } else {
+    throw new Error("Route not set")
+  }
+})

test/integration/features/step_definitions/command.ts

@@ -0,0 +1,6 @@
+import { When } from "@cucumber/cucumber"
+import { IntegrationBundleServerWorld } from '../support/world'
+
+When('I run the bundle server CLI command {string}', async function (this: IntegrationBundleServerWorld, command: string) {
+  this.runCommand(command)
+})

test/integration/features/step_definitions/remote.ts

@@ -0,0 +1,26 @@
+import { Given } from '@cucumber/cucumber'
+import { IntegrationBundleServerWorld } from '../support/world'
+import * as utils from '../../../shared/support/utils'
+import { randomBytes } from 'crypto'
+
+Given('the remote is cloned', async function (this: IntegrationBundleServerWorld) {
+  this.cloneRepository()
+})
+
+Given('{int} commits are pushed to the remote branch {string}', async function (this: IntegrationBundleServerWorld, commitNum: number, branch: string) {
+  if (this.local) {
+    for (let i = 0; i < commitNum; i++) {
+      utils.assertStatus(0, this.runShell(`echo ${randomBytes(16).toString('hex')} >${this.local.root}/README.md`))
+      utils.assertStatus(0, utils.runGit("-C", this.local.root, "add", "README.md"))
+      utils.assertStatus(0, utils.runGit("-C", this.local.root, "commit", "-m", `test ${i + 1}`))
+    }
+  } else {
+    throw new Error("Local repo not initialized")
+  }
+
+  if (this.remote) {
+    utils.assertStatus(0, utils.runGit("-C", this.local.root, "push", "origin", branch))
+  } else {
+    throw new Error("Remote repo not initialized")
+  }
+})

test/integration/features/support/world.ts

@@ -0,0 +1,31 @@
+import * as child_process from 'child_process'
+import { RemoteRepo } from '../../../shared/classes/remote'
+import { ClonedRepository } from '../../../shared/classes/repository'
+import { BundleServerWorldBase } from '../../../shared/support/world'
+import { setWorldConstructor } from '@cucumber/cucumber'
+
+export class IntegrationBundleServerWorld extends BundleServerWorldBase {
+  remote: RemoteRepo | undefined
+  local: ClonedRepository | undefined
+
+  commandResult: child_process.SpawnSyncReturns<Buffer> | undefined
+
+  runCommand(commandArgs: string): void {
+    this.commandResult = child_process.spawnSync(`${this.parameters.bundleServerCommand} ${commandArgs}`, [], { shell: true })
+  }
+
+  runShell(command: string, ...args: string[]): child_process.SpawnSyncReturns<Buffer> {
+    return child_process.spawnSync(command, args, { shell: true })
+  }
+
+  cloneRepository(): void {
+    if (!this.remote) {
+      throw new Error("Remote repository is not initialized")
+    }
+
+    const repoRoot = `${this.trashDirectory}/client`
+    this.local = new ClonedRepository(this.remote, repoRoot)
+  }
+}
+
+setWorldConstructor(IntegrationBundleServerWorld)

test/shared/classes/bundleServer.ts

@@ -1,6 +1,8 @@
 import { randomBytes } from 'crypto'
 import * as child_process from 'child_process'
 import { RemoteRepo } from './remote'
+import * as fs from 'fs'
+import * as utils from '../support/utils'
 
 export class BundleServer {
   private bundleServerCmd: string
@@ -11,7 +13,8 @@ export class BundleServer {
   private bundleUriBase: string | undefined
 
   // Remote repo info (for now, only support one per test)
-  private route: string | undefined
+  route: string | undefined
+  initialBundleCount: number | undefined
 
   constructor(bundleServerCmd: string, bundleWebServerCmd: string) {
     this.bundleServerCmd = bundleServerCmd
@@ -26,9 +29,21 @@ export class BundleServer {
     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])
+  init(remote: RemoteRepo, routePrefix: string, route: string = ""): child_process.SpawnSyncReturns<Buffer> {
+    if (route === "") {
+      route = `${routePrefix}/${randomBytes(8).toString('hex')}`
+    }
+    this.route = route
+
+    const repoPath = utils.repoRoot(route)
+    if (fs.existsSync(repoPath)) {
+      throw new Error("Bundle server repository already exists")
+    }
+
+    const result = child_process.spawnSync(this.bundleServerCmd, ["init", remote.remoteUri, this.route])
+    this.initialBundleCount = this.getBundleCount()
+
+    return result
   }
 
   update(): child_process.SpawnSyncReturns<Buffer> {
@@ -49,6 +64,23 @@ export class BundleServer {
     return this.bundleUriBase + this.route
   }
 
+  getBundleCount(): number {
+    if (!this.route) {
+      throw new Error("Route is not defined")
+    }
+
+    var matches: string[] = [];
+    const files = fs.readdirSync(`${utils.wwwPath()}/${this.route}`);
+
+    for (const file of files) {
+      if (file.endsWith('.bundle')) {
+        matches.push(file);
+      }
+    }
+
+    return matches.length;
+  }
+
   cleanup(): void {
     if (this.webServerProcess) {
       const killed = this.webServerProcess.kill('SIGINT')

test/shared/classes/repository.ts

@@ -4,9 +4,9 @@ import * as utils from '../support/utils'
 
 export class ClonedRepository {
   private initialized: boolean
-  private root: string
   private remote: RemoteRepo | undefined
 
+  root: string
   cloneResult: child_process.SpawnSyncReturns<Buffer>
   cloneTimeMs: number
 

test/shared/support/utils.ts

@@ -2,6 +2,8 @@ import * as assert from 'assert'
 import * as child_process from 'child_process'
 import * as path from 'path'
 
+const bundleRoot = `${process.env.HOME}/git-bundle-server`
+
 export function absPath(pathParam: string): string {
   // Convert a given path (either relative to the top-level project directory or
   // absolute) to an absolute path
@@ -24,3 +26,19 @@ export function assertStatus(expectedStatusCode: number, result: child_process.S
     assert.strictEqual(result.status, expectedStatusCode,
       `${message ?? "Invalid status code"}:\n\tstdout: ${result.stdout.toString()}\n\tstderr: ${result.stderr.toString()}`)
 }
+
+export function wwwPath(): string {
+  return path.resolve(bundleRoot, "www")
+}
+
+export function repoRoot(pathParam: string): string {
+  if (!path.isAbsolute(pathParam)) {
+    return path.resolve(bundleRoot, "git", pathParam)
+  } else {
+    return pathParam
+  }
+}
+
+export function routesPath(): string {
+  return path.resolve(bundleRoot, "routes")
+}