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

@@ -10,7 +10,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")
   }
-  shared_utils.assertStatus(0, this.bundleServer.init(this.remote))
+  shared_utils.assertStatus(0, this.bundleServer.init(this.remote, 'e2e'))
 })
 
 Given('the bundle server was updated for the remote repo', async function (this: BundleServerWorld) {

test/integration/features/command.feature

@@ -0,0 +1,40 @@
+Feature: Bundle server command tests
+
+  Background: The bundle web server is running
+    Given the bundle web server was started at port 8080
+
+  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'
+
+  Scenario: The delete command removes route configuration and repository data
+    Given a remote repository exists at url '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,76 @@
+import * as assert from 'assert'
+import { BundleServerWorld, } from '../support/world'
+import { Given, Then } from '@cucumber/cucumber'
+import * as shared_utils from '../../../shared/support/utils'
+import * as fs from 'fs'
+
+Given('the bundle web server was started at port {int}', async function (this: BundleServerWorld, port: number) {
+  this.bundleServer.startWebServer(port)
+})
+
+Given('a bundle server repository is created at route {string} for the remote', async function (this: BundleServerWorld, 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: BundleServerWorld, route: string) {
+  var repoPath = shared_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: BundleServerWorld, route: string) {
+  var repoRoot = shared_utils.repoRoot(route)
+  assert.equal(fs.existsSync(repoRoot), true)
+  assert.equal(fs.existsSync(`${repoRoot}/.git`), false)
+  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: BundleServerWorld, route: string) {
+  var repoRoot = shared_utils.repoRoot(route)
+  var routeData = fs.readFileSync(shared_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: BundleServerWorld) {
+  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: BundleServerWorld) {
+  if (this.bundleServer.route) {
+    var routesPath = shared_utils.routesPath()
+    var data = fs.readFileSync(routesPath, 'utf-8');
+    assert.strictEqual(data.includes(this.bundleServer.route), false)
+  }
+})
+
+Then('the route exists in the routes file', async function (this: BundleServerWorld) {
+  if (this.bundleServer.route) {
+    var routesPath = shared_utils.routesPath()
+    var data = fs.readFileSync(routesPath, 'utf-8');
+    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 { BundleServerWorld } from "../support/world"
+
+When('I run the bundle server CLI command {string}', async function (this: BundleServerWorld, command: string) {
+  this.runCommand(command)
+})

test/integration/features/step_definitions/remote.ts

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

test/integration/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/integration/features/support/world.ts

@@ -1,10 +1,59 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
 import * as child_process from 'child_process'
+import { RemoteRepo } from '../../../shared/classes/remote'
+import * as local_utils from './utils'
+import * as fs from 'fs'
+import { ClonedRepository } from '../../../shared/classes/repository'
+import {BundleServer} from '../../../shared/classes/bundleServer'
+import { randomUUID } from 'crypto'
+import * as path from 'path'
 
 interface BundleServerParameters {
   bundleServerCommand: string
+  bundleWebServerCommand: string
+  trashDirectoryBase: string
 }
 
-export class BundleServerWorld extends World<BundleServerParameters> { }
+export class BundleServerWorld extends World<BundleServerParameters> {
+  trashDirectory: string
+  bundleServer: BundleServer
+
+  remote: RemoteRepo | undefined
+  local: ClonedRepository | undefined
+
+  commandResult: child_process.SpawnSyncReturns<Buffer> | undefined
+
+  constructor(options: IWorldOptions<BundleServerParameters>) {
+    super(options)
+
+    this.bundleServer = new BundleServer(this.parameters.bundleServerCommand,
+      this.parameters.bundleWebServerCommand)
+
+    // Set up the trash directory
+    this.trashDirectory = path.join(local_utils.absPath(this.parameters.trashDirectoryBase), randomUUID())
+    fs.mkdirSync(this.trashDirectory, { recursive: true });
+  }
+
+  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)
+  }
+
+  cleanup(): void {
+    this.bundleServer.cleanup()
+  }
+}
 
 setWorldConstructor(BundleServerWorld)

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 shared_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

@@ -1,5 +1,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 runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
     return child_process.spawnSync("git", args)
@@ -12,3 +15,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")
+}