e2e tests: updates for integration tests

Update necessary components of existing e2e tests to prepare for new
integration test suite. This includes:

1. Moving package-related files (package-lock.json, package.json, and
tsconfig.json) out of the 'e2e' directory and into 'test' and updating
package.json to not be e2e-test specific. This will allow both suites to
be combined into a single Typescript package in upcoming patches.i

2. Moving certain classes currently in the e2e 'step_definitions',
'support', and 'classes' directories that will be needed by integration
tests into a new 'shared' directory. This led to notable refactorings to
implement the shared 'BundleServerWorld' class as a parent and a new
'E2EBundleServerWorld' class as a child. A similar
'IntegrationBundleServerWorld' class will be added in a future patch.

3. Updating the 'require' statement in the e2e tests' config to identify
the correct 'features' directories with the new architecture. This
indicates to Cucumber that it should look in multiple directories for
features. The VSCode settings have been updated to recognize these
directories as well.

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

Author: ldennington

.vscode/settings.json

@@ -40,9 +40,9 @@
 
     // Cucumber settings
     "cucumber.features": [
-        "test/e2e/features/**/*.feature",
+        "test/**/features/**/*.feature",
     ],
     "cucumber.glue": [
-        "test/e2e/features/**/*.ts"
+        "test/**/features/**/*.ts",
     ],
 }

scripts/run-e2e-tests.sh

@@ -30,4 +30,4 @@ set -e
 cd "$TESTDIR"
 
 npm install
-npm run test -- ${ARGS:+${ARGS[*]}}
+npm run e2e-test -- ${ARGS:+${ARGS[*]}}

test/e2e/cucumber.js

@@ -1,15 +1,15 @@
 const common = {
   requireModule: ['ts-node/register'],
-  require: ['features/**/*.ts'],
+  require: [`${__dirname}/features/**/*.ts`, `${__dirname}/../shared/features/**/*.ts`],
   publishQuiet: true,
   format: ['progress'],
   formatOptions: {
     snippetInterface: 'async-await'
   },
   worldParameters: {
-    bundleServerCommand: '../../bin/git-bundle-server',
-    bundleWebServerCommand: '../../bin/git-bundle-web-server',
-    trashDirectoryBase: '../../_test/e2e'
+    bundleServerCommand: 'bin/git-bundle-server',
+    bundleWebServerCommand: 'bin/git-bundle-web-server',
+    trashDirectoryBase: '_test/e2e'
   }
 }
 

test/e2e/features/step_definitions/bundleServer.ts

@@ -1,18 +1,14 @@
-import * as utils from '../support/utils'
-import { BundleServerWorld, } from '../support/world'
+import * as utils from '../../../shared/support/utils'
+import { EndToEndBundleServerWorld } from '../support/world'
 import { Given } from '@cucumber/cucumber'
 
-Given('the bundle web server was started at port {int}', async function (this: BundleServerWorld, port: number) {
-  this.bundleServer.startWebServer(port)
-})
-
-Given('the bundle server has been initialized with the remote repo', async function (this: BundleServerWorld) {
+Given('the bundle server has been initialized with the remote repo', async function (this: EndToEndBundleServerWorld) {
   if (this.remote === undefined) {
     throw new Error("Remote repository is not initialized")
   }
   utils.assertStatus(0, this.bundleServer.init(this.remote))
 })
 
-Given('the bundle server was updated for the remote repo', async function (this: BundleServerWorld) {
+Given('the bundle server was updated for the remote repo', async function (this: EndToEndBundleServerWorld) {
   utils.assertStatus(0, this.bundleServer.update())
 })

test/e2e/features/step_definitions/repository.ts

@@ -1,7 +1,7 @@
 import * as assert from 'assert'
-import * as utils from '../support/utils'
+import * as utils from '../../../shared/support/utils'
 import { randomBytes } from 'crypto'
-import { BundleServerWorld, User } from '../support/world'
+import { EndToEndBundleServerWorld, User } from '../support/world'
 import { Given, When, Then } from '@cucumber/cucumber'
 
 /**
@@ -10,7 +10,7 @@ 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) {
+Given('another user pushed {int} commits to {string}', async function (this: EndToEndBundleServerWorld, commitNum: number, branch: string) {
   const clonedRepo = this.getRepoAtBranch(User.Another, branch)
 
   for (let i = 0; i < commitNum; i++) {
@@ -22,7 +22,7 @@ Given('another user pushed {int} commits to {string}', async function (this: Bun
 })
 
 Given('another user removed {int} commits and added {int} commits to {string}',
-  async function (this: BundleServerWorld, removeCommits: number, addCommits: number, branch: string) {
+  async function (this: EndToEndBundleServerWorld, removeCommits: number, addCommits: number, branch: string) {
     const clonedRepo = this.getRepoAtBranch(User.Another, branch)
 
     // First, reset
@@ -40,33 +40,33 @@ Given('another user removed {int} commits and added {int} commits to {string}',
   }
 )
 
-Given('I cloned from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
+Given('I cloned from the remote repo with a bundle URI', async function (this: EndToEndBundleServerWorld) {
   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) {
+When('I clone from the remote repo with a bundle URI', async function (this: EndToEndBundleServerWorld) {
   this.cloneRepositoryFor(User.Me, this.bundleServer.bundleUri())
 })
 
-When('another developer clones from the remote repo without a bundle URI', async function (this: BundleServerWorld) {
+When('another developer clones from the remote repo without a bundle URI', async function (this: EndToEndBundleServerWorld) {
   this.cloneRepositoryFor(User.Another)
 })
 
-When('I fetch from the remote', async function (this: BundleServerWorld) {
+When('I fetch from the remote', async function (this: EndToEndBundleServerWorld) {
   const clonedRepo = this.getRepo(User.Me)
   utils.assertStatus(0, clonedRepo.runGit("fetch", "origin"))
 })
 
-Then('bundles are downloaded and used', async function (this: BundleServerWorld) {
+Then('bundles are downloaded and used', async function (this: EndToEndBundleServerWorld) {
   const clonedRepo = this.getRepo(User.Me)
 
   // Verify the clone executed as-expected
   utils.assertStatus(0, clonedRepo.cloneResult, "git clone failed")
 
   // Ensure warning wasn't thrown
-  clonedRepo.cloneResult.stderr.toString().split("\n").forEach(function (line) {
+  clonedRepo.cloneResult.stderr.toString().split("\n").forEach(function (line: string) {
     if (line.startsWith("warning: failed to download bundle from URI")) {
       assert.fail(line)
     }
@@ -81,13 +81,13 @@ Then('bundles are downloaded and used', async function (this: BundleServerWorld)
   result = clonedRepo.runGit("for-each-ref", "--format=%(refname)", "refs/bundles/*")
   utils.assertStatus(0, result, "git for-each-ref failed")
 
-  const bundleRefs = result.stdout.toString().split("\n").filter(function(line) {
+  const bundleRefs = result.stdout.toString().split("\n").filter(function(line: string) {
     return line.trim() != ""
   })
   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) {
+Then('I am up-to-date with {string}', async function (this: EndToEndBundleServerWorld, branch: string) {
   const clonedRepo = this.getRepo(User.Me)
   const result = clonedRepo.runGit("rev-parse", `refs/remotes/origin/${branch}`)
   utils.assertStatus(0, result)
@@ -97,7 +97,7 @@ Then('I am up-to-date with {string}', async function (this: BundleServerWorld, b
 })
 
 Then('my repo\'s bundles {boolean} up-to-date with {string}',
-  async function (this: BundleServerWorld, expectedUpToDate: boolean, branch: string) {
+  async function (this: EndToEndBundleServerWorld, expectedUpToDate: boolean, branch: string) {
     const clonedRepo = this.getRepo(User.Me)
     const result = clonedRepo.runGit("rev-parse", `refs/bundles/${branch}`)
     utils.assertStatus(0, result)
@@ -112,7 +112,7 @@ Then('my repo\'s bundles {boolean} up-to-date with {string}',
   }
 )
 
-Then('I compare the clone execution times', async function (this: BundleServerWorld) {
+Then('I compare the clone execution times', async function (this: EndToEndBundleServerWorld) {
   const myClone = this.getRepo(User.Me)
   const otherClone = this.getRepo(User.Another)
 

test/e2e/features/support/utils.ts

@@ -1,46 +1,21 @@
-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'
-import * as path from 'path'
-import { ClonedRepository } from '../classes/repository'
-import { BundleServer } from '../classes/bundleServer'
+import { setWorldConstructor, IWorldOptions } from '@cucumber/cucumber'
+import * as utils from '../../../shared/support/utils'
+import { ClonedRepository } from '../../../shared/classes/repository'
+import { BundleServerWorldBase, BundleServerParameters } from '../../../shared/support/world'
 
 export enum User {
   Me = 1,
   Another,
 }
 
-interface BundleServerParameters {
-  bundleServerCommand: string
-  bundleWebServerCommand: string
-  trashDirectoryBase: string
-}
-
-export class BundleServerWorld extends World<BundleServerParameters> {
-  // Internal variables
-  trashDirectory: string
-
-  // Bundle server
-  bundleServer: BundleServer
-  remote: RemoteRepo | undefined
-
+export class EndToEndBundleServerWorld extends BundleServerWorldBase {
   // Users
   repoMap: Map<User, ClonedRepository>
 
   constructor(options: IWorldOptions<BundleServerParameters>) {
     super(options)
 
     this.repoMap = new Map<User, ClonedRepository>()
-
-    // Set up the trash directory
-    this.trashDirectory = path.join(utils.absPath(this.parameters.trashDirectoryBase), randomUUID())
-    fs.mkdirSync(this.trashDirectory, { recursive: true });
-
-    // Set up the bundle server
-    this.bundleServer = new BundleServer(utils.absPath(this.parameters.bundleServerCommand),
-      utils.absPath(this.parameters.bundleWebServerCommand))
   }
 
   cloneRepositoryFor(user: User, bundleUri?: string): void {
@@ -84,13 +59,6 @@ export class BundleServerWorld extends World<BundleServerParameters> {
 
     return clonedRepo
   }
-
-  cleanup(): void {
-    this.bundleServer.cleanup()
-
-    // Delete the trash directory
-    fs.rmSync(this.trashDirectory, { recursive: true })
-  }
 }
 
-setWorldConstructor(BundleServerWorld)
+setWorldConstructor(EndToEndBundleServerWorld)