init and list tests

Author: ldennington

test/integration/features/command.feature

@@ -0,0 +1,15 @@
+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 list command lists route and remote
+    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 'list'
+    Then the routes and remotes are listed

test/integration/features/step_definitions/bundleServer.ts

@@ -0,0 +1,12 @@
+import * as assert from 'assert'
+import { BundleServerWorld, } from '../support/world'
+import { Given, Then } from '@cucumber/cucumber'
+
+Given('the bundle web server was started at port {int}', async function (this: BundleServerWorld, port: number) {
+  this.runCommand(`web-server start --port ${port}`)
+})
+
+Then('the routes and remotes are listed', async function (this: BundleServerWorld) {
+  assert.strictEqual(this.commandResult?.stdout.toString()
+    .includes(`${this.route} \t${this.remote?.remoteUri}`), true)
+})

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,7 @@
+import { Given } from "@cucumber/cucumber"
+import { RemoteRepo } from "../../../shared/classes/remote"
+import { BundleServerWorld } from "../support/world"
+
+Given('a remote repository exists at url {string}', async function (this: BundleServerWorld, url: string) {
+  this.remote = new RemoteRepo(false, url)
+})

test/integration/features/step_definitions/repository.ts

@@ -0,0 +1,26 @@
+import { Given, Then } from "@cucumber/cucumber"
+import * as local_utils from '../support/utils'
+import { BundleServerWorld } from "../support/world"
+import * as fs from 'fs'
+import * as assert from 'assert'
+
+Given('a bundle server repository is created at route {string} for the remote', async function (this: BundleServerWorld, route: string) {
+  this.init(route)
+})
+
+Given('no bundle server repository exists at route {string}', async function (this: BundleServerWorld, route: string) {
+  var repoPath = local_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 = local_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.route = route
+})

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,13 +1,50 @@
 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'
 
 interface BundleServerParameters {
   bundleServerCommand: string
 }
 
 export class BundleServerWorld extends World<BundleServerParameters> {
-  runCommand(commandArgs: string): child_process.SpawnSyncReturns<Buffer> {
-    return child_process.spawnSync(`${this.parameters.bundleServerCommand} ${commandArgs}`, [], { shell: true })
+  route: string | undefined
+
+  remote: RemoteRepo | undefined
+  commandResult: child_process.SpawnSyncReturns<Buffer> | undefined
+
+  init(route: string): void {
+    if (!this.remote) {
+      throw new Error("Remote repository is not initialized")
+    }
+
+    var repoPath = local_utils.repoRoot(route)
+    if (!fs.existsSync(repoPath)) {
+      this.runCommand(`init ${this.remote?.remoteUri} ${route}`)
+    } else {
+      throw new Error("Repository already exists")
+    }
+
+    this.route = route
+  }
+
+  runCommand(commandArgs: string): void {
+    this.commandResult = child_process.spawnSync(`${this.parameters.bundleServerCommand} ${commandArgs}`, [], { shell: true })
+  }
+
+  cleanup(): void {
+    if (this.route) {
+      child_process.spawnSync(`delete ${this.route}`)
+      fs.rmSync(local_utils.repoRoot(this.route), { recursive: true })
+
+      var routesPath = local_utils.routesPath()
+      var data = fs.readFileSync(routesPath, 'utf-8');
+
+      var newValue = data.replace(this.route, '');
+
+      fs.writeFileSync(routesPath, newValue);
+    }
   }
 }