delete test

Author: ldennington

test/integration/features/command.feature

@@ -13,3 +13,19 @@ Feature: Bundle server command tests
     Given a bundle server repository is created at route 'integration/asset-hash' for the remote
     When I run the bundle server CLI command 'list'
     Then the routes and remotes are listed
+
+  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 bundle list is updated

test/integration/features/step_definitions/bundleServer.ts

@@ -1,6 +1,8 @@
 import * as assert from 'assert'
 import { BundleServerWorld, } from '../support/world'
 import { Given, Then } from '@cucumber/cucumber'
+import * as local_utils from '../support/utils'
+import * as fs from 'fs'
 
 Given('the bundle web server was started at port {int}', async function (this: BundleServerWorld, port: number) {
   this.runCommand(`web-server start --port ${port}`)
@@ -10,3 +12,21 @@ Then('the routes and remotes are listed', async function (this: BundleServerWorl
   assert.strictEqual(this.commandResult?.stdout.toString()
     .includes(`${this.route} \t${this.remote?.remoteUri}`), true)
 })
+
+Then('the route configuration and repository data at {string} are removed', async function (this: BundleServerWorld, route: string) {
+  var repoRoot = local_utils.repoRoot(route)
+  var routeData = fs.readFileSync(local_utils.routesPath())
+
+  assert.equal(fs.existsSync(repoRoot), false)
+  assert.equal(routeData.includes(route), false)
+
+  // Reset route to be ignored in cleanup
+  this.route = undefined
+})
+
+Then('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)
+})

test/integration/features/step_definitions/remote.ts

@@ -1,7 +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/support/world.ts

@@ -3,17 +3,32 @@ 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 { randomUUID } from 'crypto'
+import * as path from 'path'
 
 interface BundleServerParameters {
   bundleServerCommand: string
+  trashDirectoryBase: string
 }
 
 export class BundleServerWorld extends World<BundleServerParameters> {
   route: string | undefined
+  trashDirectory: string
 
   remote: RemoteRepo | undefined
+  local: ClonedRepository | undefined
   commandResult: child_process.SpawnSyncReturns<Buffer> | undefined
 
+  constructor(options: IWorldOptions<BundleServerParameters>) {
+    super(options)
+    this.route = ""
+
+    // Set up the trash directory
+    this.trashDirectory = path.join(local_utils.absPath(this.parameters.trashDirectoryBase), randomUUID())
+    fs.mkdirSync(this.trashDirectory, { recursive: true });
+  }
+
   init(route: string): void {
     if (!this.remote) {
       throw new Error("Remote repository is not initialized")
@@ -33,6 +48,19 @@ export class BundleServerWorld extends World<BundleServerParameters> {
     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 {
     if (this.route) {
       child_process.spawnSync(`delete ${this.route}`)

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