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 sepcific. This will allow both suites to
be combined into a single Typescript package in upcoming patches.

2. Updating the 'require' statement in the e2e tests' config to identify
the correct 'features' directory with the new architecture.

3. Moving certain classes currently in the e2e 'support' and 'classes'
directories that will be needed by integration tests into a new 'shared'
directory. Note that while certain pieces of the current 'utils' file were
moved to 'shared', the absPath function was left in the original 'utils'
file given it finds paths relative to test/e2e. Utils imports have been
prefixed with 'local'/'shared' to account for the two files.

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

Author: ldennington

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,6 +1,6 @@
 const common = {
   requireModule: ['ts-node/register'],
-  require: ['features/**/*.ts'],
+  require: [`${__dirname}/features/**/*.ts`],
   publishQuiet: true,
   format: ['progress'],
   formatOptions: {

test/e2e/features/step_definitions/bundleServer.ts

@@ -1,4 +1,4 @@
-import * as utils from '../support/utils'
+import * as shared_utils from '../../../shared/support/utils'
 import { BundleServerWorld, } from '../support/world'
 import { Given } from '@cucumber/cucumber'
 
@@ -10,9 +10,9 @@ 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))
+  shared_utils.assertStatus(0, this.bundleServer.init(this.remote))
 })
 
 Given('the bundle server was updated for the remote repo', async function (this: BundleServerWorld) {
-  utils.assertStatus(0, this.bundleServer.update())
+  shared_utils.assertStatus(0, this.bundleServer.update())
 })

test/e2e/features/step_definitions/remote.ts

@@ -1,5 +1,5 @@
 import { Given, } from '@cucumber/cucumber'
-import { RemoteRepo } from '../classes/remote'
+import { RemoteRepo } from '../../../shared/classes/remote'
 import { BundleServerWorld } from '../support/world'
 import * as path from 'path'
 

test/e2e/features/step_definitions/repository.ts

@@ -1,5 +1,5 @@
 import * as assert from 'assert'
-import * as utils from '../support/utils'
+import * as shared_utils from '../../../shared/support/utils'
 import { randomBytes } from 'crypto'
 import { BundleServerWorld, User } from '../support/world'
 import { Given, When, Then } from '@cucumber/cucumber'
@@ -14,36 +14,36 @@ Given('another user pushed {int} commits to {string}', async function (this: Bun
   const clonedRepo = this.getRepoAtBranch(User.Another, branch)
 
   for (let i = 0; i < commitNum; i++) {
-    utils.assertStatus(0, clonedRepo.runShell(`echo ${randomBytes(16).toString('hex')} >README.md`))
-    utils.assertStatus(0, clonedRepo.runGit("add", "README.md"))
-    utils.assertStatus(0, clonedRepo.runGit("commit", "-m", `test ${i + 1}`))
+    shared_utils.assertStatus(0, clonedRepo.runShell(`echo ${randomBytes(16).toString('hex')} >README.md`))
+    shared_utils.assertStatus(0, clonedRepo.runGit("add", "README.md"))
+    shared_utils.assertStatus(0, clonedRepo.runGit("commit", "-m", `test ${i + 1}`))
   }
-  utils.assertStatus(0, clonedRepo.runGit("push", "origin", branch))
+  shared_utils.assertStatus(0, clonedRepo.runGit("push", "origin", branch))
 })
 
 Given('another user removed {int} commits and added {int} commits to {string}',
   async function (this: BundleServerWorld, removeCommits: number, addCommits: number, branch: string) {
     const clonedRepo = this.getRepoAtBranch(User.Another, branch)
 
     // First, reset
-    utils.assertStatus(0, clonedRepo.runGit("reset", "--hard", `HEAD~${removeCommits}`))
+    shared_utils.assertStatus(0, clonedRepo.runGit("reset", "--hard", `HEAD~${removeCommits}`))
 
     // Then, add new commits
     for (let i = 0; i < addCommits; i++) {
-      utils.assertStatus(0, clonedRepo.runShell(`echo ${randomBytes(16).toString('hex')} >README.md`))
-      utils.assertStatus(0, clonedRepo.runGit("add", "README.md"))
-      utils.assertStatus(0, clonedRepo.runGit("commit", "-m", `test ${i + 1}`))
+      shared_utils.assertStatus(0, clonedRepo.runShell(`echo ${randomBytes(16).toString('hex')} >README.md`))
+      shared_utils.assertStatus(0, clonedRepo.runGit("add", "README.md"))
+      shared_utils.assertStatus(0, clonedRepo.runGit("commit", "-m", `test ${i + 1}`))
     }
 
     // Finally, force push
-    utils.assertStatus(0, clonedRepo.runGit("push", "-f", "origin", branch))
+    shared_utils.assertStatus(0, clonedRepo.runGit("push", "-f", "origin", branch))
   }
 )
 
 Given('I cloned from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
   const user = User.Me
   this.cloneRepositoryFor(user, this.bundleServer.bundleUri())
-  utils.assertStatus(0, this.getRepo(user).cloneResult)
+  shared_utils.assertStatus(0, this.getRepo(user).cloneResult)
 })
 
 When('I clone from the remote repo with a bundle URI', async function (this: BundleServerWorld) {
@@ -56,14 +56,14 @@ When('another developer clones from the remote repo without a bundle URI', async
 
 When('I fetch from the remote', async function (this: BundleServerWorld) {
   const clonedRepo = this.getRepo(User.Me)
-  utils.assertStatus(0, clonedRepo.runGit("fetch", "origin"))
+  shared_utils.assertStatus(0, clonedRepo.runGit("fetch", "origin"))
 })
 
 Then('bundles are downloaded and used', async function (this: BundleServerWorld) {
   const clonedRepo = this.getRepo(User.Me)
 
   // Verify the clone executed as-expected
-  utils.assertStatus(0, clonedRepo.cloneResult, "git clone failed")
+  shared_utils.assertStatus(0, clonedRepo.cloneResult, "git clone failed")
 
   // Ensure warning wasn't thrown
   clonedRepo.cloneResult.stderr.toString().split("\n").forEach(function (line) {
@@ -74,12 +74,12 @@ Then('bundles are downloaded and used', async function (this: BundleServerWorld)
 
   // Make sure the config is set up properly
   let result = clonedRepo.runGit("config", "--get", "fetch.bundleURI")
-  utils.assertStatus(0, result, "'fetch.bundleURI' is not set after clone")
+  shared_utils.assertStatus(0, result, "'fetch.bundleURI' is not set after clone")
   const actualURI = result.stdout.toString().trim()
   assert.strictEqual(actualURI, this.bundleServer.bundleUri())
 
   result = clonedRepo.runGit("for-each-ref", "--format=%(refname)", "refs/bundles/*")
-  utils.assertStatus(0, result, "git for-each-ref failed")
+  shared_utils.assertStatus(0, result, "git for-each-ref failed")
 
   const bundleRefs = result.stdout.toString().split("\n").filter(function(line) {
     return line.trim() != ""
@@ -90,7 +90,7 @@ Then('bundles are downloaded and used', async function (this: BundleServerWorld)
 Then('I am up-to-date with {string}', async function (this: BundleServerWorld, branch: string) {
   const clonedRepo = this.getRepo(User.Me)
   const result = clonedRepo.runGit("rev-parse", `refs/remotes/origin/${branch}`)
-  utils.assertStatus(0, result)
+  shared_utils.assertStatus(0, result)
   const actualOid = result.stdout.toString().trim()
   const expectedOid = this.remote?.getBranchTipOid(branch)
   assert.strictEqual(actualOid, expectedOid, `branch '${branch}' is not up-to-date`)
@@ -100,7 +100,7 @@ Then('my repo\'s bundles {boolean} up-to-date with {string}',
   async function (this: BundleServerWorld, expectedUpToDate: boolean, branch: string) {
     const clonedRepo = this.getRepo(User.Me)
     const result = clonedRepo.runGit("rev-parse", `refs/bundles/${branch}`)
-    utils.assertStatus(0, result)
+    shared_utils.assertStatus(0, result)
     const actualOid = result.stdout.toString().trim()
     const expectedOid = this.remote?.getBranchTipOid(branch)
 
@@ -117,8 +117,8 @@ Then('I compare the clone execution times', async function (this: BundleServerWo
   const otherClone = this.getRepo(User.Another)
 
   // Verify the clones succeeded
-  utils.assertStatus(0, myClone.cloneResult)
-  utils.assertStatus(0, otherClone.cloneResult)
+  shared_utils.assertStatus(0, myClone.cloneResult)
+  shared_utils.assertStatus(0, otherClone.cloneResult)
 
   console.log(`\nClone execution time for ${this.remote!.remoteUri}: ${(myClone.cloneTimeMs / 1000).toFixed(2)}s (bundle URI) vs. ${(otherClone.cloneTimeMs / 1000).toFixed(2)}s (no bundle URI)`)
 })

test/e2e/features/support/utils.ts

@@ -1,10 +1,4 @@
 import * as path from 'path'
-import * as assert from 'assert'
-import * as child_process from 'child_process'
-
-export function runGit(...args: string[]): child_process.SpawnSyncReturns<Buffer> {
-  return child_process.spawnSync("git", args)
-}
 
 export function absPath(pathParam: string): string {
   // Convert a given path (either relative to 'test/e2e/' or absolute) to an
@@ -15,11 +9,3 @@ export function absPath(pathParam: string): string {
     return pathParam
   }
 }
-
-export function assertStatus(expectedStatusCode: number, result: child_process.SpawnSyncReturns<Buffer>, message?: string): void {
-  if (result.error) {
-    throw result.error
-  }
-  assert.strictEqual(result.status, expectedStatusCode,
-    `${message ?? "Invalid status code"}:\n\tstdout: ${result.stdout.toString()}\n\tstderr: ${result.stderr.toString()}`)
-}

test/e2e/features/support/world.ts

@@ -1,11 +1,12 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
 import { randomUUID } from 'crypto'
-import { RemoteRepo } from '../classes/remote'
-import * as utils from './utils'
+import { RemoteRepo } from '../../../shared/classes/remote'
+import * as local_utils from './utils'
+import * as shared_utils from '../../../shared/support/utils'
 import * as fs from 'fs'
 import * as path from 'path'
-import { ClonedRepository } from '../classes/repository'
-import { BundleServer } from '../classes/bundleServer'
+import { ClonedRepository } from '../../../shared/classes/repository'
+import { BundleServer } from '../../../shared/classes/bundleServer'
 
 export enum User {
   Me = 1,
@@ -35,12 +36,12 @@ export class BundleServerWorld extends World<BundleServerParameters> {
     this.repoMap = new Map<User, ClonedRepository>()
 
     // Set up the trash directory
-    this.trashDirectory = path.join(utils.absPath(this.parameters.trashDirectoryBase), randomUUID())
+    this.trashDirectory = path.join(local_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))
+    this.bundleServer = new BundleServer(local_utils.absPath(this.parameters.bundleServerCommand),
+      local_utils.absPath(this.parameters.bundleWebServerCommand))
   }
 
   cloneRepositoryFor(user: User, bundleUri?: string): void {
@@ -68,18 +69,18 @@ export class BundleServerWorld extends World<BundleServerParameters> {
 
     if (!this.repoMap.has(user)) {
       this.cloneRepositoryFor(user)
-      utils.assertStatus(0, this.getRepo(user).cloneResult)
+      shared_utils.assertStatus(0, this.getRepo(user).cloneResult)
     }
 
     const clonedRepo = this.getRepo(user)
 
     const result = clonedRepo.runGit("rev-list", "--all", "-n", "1")
     if (result.stdout.toString().trim() == "") {
       // Repo is empty, so make sure we're on the right branch
-      utils.assertStatus(0, clonedRepo.runGit("branch", "-m", branch))
+      shared_utils.assertStatus(0, clonedRepo.runGit("branch", "-m", branch))
     } else {
-      utils.assertStatus(0, clonedRepo.runGit("switch", branch))
-      utils.assertStatus(0, clonedRepo.runGit("pull", "origin", branch))
+      shared_utils.assertStatus(0, clonedRepo.runGit("switch", branch))
+      shared_utils.assertStatus(0, clonedRepo.runGit("pull", "origin", branch))
     }
 
     return clonedRepo