test: add shared directory

There are certain classes currently in the e2e 'support' and 'classes'
directories that will be needed by integration tests. This change moves
these functions into a new 'shared' directory.

Note that the absPath function for utils 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

test/e2e/features/classes/bundleServer.ts

@@ -1,6 +1,6 @@
 import { randomBytes } from 'crypto'
 import * as child_process from 'child_process'
-import { RemoteRepo } from './remote'
+import { RemoteRepo } from '../../../shared/classes/remote'
 
 export class BundleServer {
   private bundleServerCmd: string

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,10 +1,11 @@
 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 { ClonedRepository } from '../../../shared/classes/repository'
 import { BundleServer } from '../classes/bundleServer'
 
 export enum User {
@@ -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

test/e2e/features/classes/remote.ts renamed to test/shared/classes/remote.ts

@@ -1,5 +1,5 @@
 import * as path from 'path'
-import * as utils from '../support/utils'
+import * as shared_utils from '../support/utils'
 import * as child_process from 'child_process'
 
 export class RemoteRepo {
@@ -25,9 +25,9 @@ export class RemoteRepo {
         throw new Error("'urlOrPath' must be a 'file://' URL or absolute path")
       }
 
-      utils.assertStatus(0, utils.runGit("init", "--bare", this.root))
+      shared_utils.assertStatus(0, shared_utils.runGit("init", "--bare", this.root))
       if (mainBranch) {
-        utils.assertStatus(0, utils.runGit("-C", this.root, "symbolic-ref", "HEAD", `refs/heads/${mainBranch}`))
+        shared_utils.assertStatus(0, shared_utils.runGit("-C", this.root, "symbolic-ref", "HEAD", `refs/heads/${mainBranch}`))
       }
     }
   }
@@ -37,7 +37,7 @@ export class RemoteRepo {
       throw new Error("Logged branch tips are only available for local custom remotes")
     }
     const result = child_process.spawnSync("cat", [`refs/heads/${branch}`], { shell: true, cwd: this.root })
-    utils.assertStatus(0, result)
+    shared_utils.assertStatus(0, result)
     return result.stdout.toString().trim()
   }
 }

test/e2e/features/classes/repository.ts renamed to test/shared/classes/repository.ts

@@ -1,6 +1,6 @@
 import * as child_process from 'child_process'
 import { RemoteRepo } from './remote'
-import * as utils from '../support/utils'
+import * as shared_utils from '../support/utils'
 
 export class ClonedRepository {
   private initialized: boolean
@@ -41,6 +41,6 @@ export class ClonedRepository {
     if (!this.initialized) {
       throw new Error("Repository is not initialized")
     }
-    return utils.runGit("-C", this.root, ...args)
+    return shared_utils.runGit("-C", this.root, ...args)
   }
 }

test/shared/support/utils.ts

@@ -0,0 +1,14 @@
+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 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()}`)
+}