Add integration tests

.github/workflows/test.yml

@@ -1,4 +1,4 @@
-name: End-to-end test
+name: Integration and end-to-end tests
 
 on:
   pull_request:
@@ -10,7 +10,7 @@ on:
         default: false
 
 jobs:
-  e2e-test:
+  tests:
     runs-on: ubuntu-latest
 
     steps:
@@ -27,11 +27,17 @@ jobs:
         with:
           node-version: 18
 
-      - name: Install system dependencies for end-to-end tests
+      - name: Install system dependencies for tests
         run: build/ci/install-dependencies.sh
         shell: bash
 
-      - name: Enable perf tests
+      - name: Run integration tests
+        run: |
+          # Ensure only integration tests that are supported in CI are run using
+          # the --ci flag.
+          make integration-test INTEGRATION_FLAGS="--ci"
+
+      - name: Enable end-to-end perf tests
         if: ${{ github.event.inputs.run-all }}
         run: echo "E2E_FLAGS='--all'" >> $GITHUB_ENV
 

.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",
     ],
 }

Makefile

@@ -28,6 +28,7 @@ APPLE_APP_IDENTITY =
 APPLE_INST_IDENTITY =
 APPLE_KEYCHAIN_PROFILE =
 E2E_FLAGS=
+INTEGRATION_FLAGS=
 
 # Build targets
 .PHONY: build
@@ -42,13 +43,28 @@ doc:
 			      --output="$(DOCDIR)"
 
 # Testing targets
+.PHONY: test
+test: build
+	@echo "======== Running unit tests ========"
+	GOOS="$(GOOS)" GOARCH="$(GOARCH)" go test ./...
+
+.PHONY: integration-test
+integration-test: build
+	@echo
+	@echo "======== Running integration tests ========"
+	$(RM) -r $(TESTDIR)
+	@scripts/run-integration-tests.sh $(INTEGRATION_FLAGS)
+
 .PHONY: e2e-test
 e2e-test: build
 	@echo
 	@echo "======== Running end-to-end tests ========"
 	$(RM) -r $(TESTDIR)
 	@scripts/run-e2e-tests.sh $(E2E_FLAGS)
 
+.PHONY: test-all
+test-all: test integration-test e2e-test
+
 # Installation targets
 .PHONY: install
 install: build doc

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[*]}}

scripts/run-integration-tests.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+THISDIR="$( cd "$(dirname "$0")" ; pwd -P )"
+TESTDIR="$THISDIR/../test/integration"
+
+# Defaults
+ARGS=()
+
+# Parse script arguments
+for i in "$@"
+do
+case "$i" in
+	--offline)
+	ARGS+=("-p" "offline")
+	shift # past argument
+	;;
+	--ci)
+	ARGS+=("-p" "ci")
+	shift # past argument
+	;;
+	*)
+	die "unknown option '$i'"
+	;;
+esac
+done
+
+# Exit as soon as any line fails
+set -e
+
+cd "$TESTDIR"
+
+npm install
+npm run integration-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))
+  utils.assertStatus(0, this.bundleServer.init(this.remote, 'e2e'))
 })
 
-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/world.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)