integration tests: daemon

Add basic tests to check whether the daemon starts/stops correctly with
the git-bundle-server web-server start and stop commands.

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

Author: ldennington

test/integration/features/classes/daemonState.ts

@@ -0,0 +1,49 @@
+import * as child_process from 'child_process'
+import { CommandRunner } from './commandRunner';
+
+export abstract class DaemonState {
+    protected commandRunner: CommandRunner
+
+    status: string | null = null
+
+    constructor () {
+      this.commandRunner = new CommandRunner()
+      this.get()
+    }
+
+    abstract get(): void
+
+    parseOutput(stdout: string, regex: RegExp): void {
+      var potentialMatchParts = stdout.match(regex)
+      if (potentialMatchParts) {
+          this.status = potentialMatchParts[1]
+      }
+      else {
+          throw new Error(`No match found for ${regex}`)
+      }
+    }
+}
+
+export class LaunchdDaemonState extends DaemonState {
+  get(): void {
+    var regex = new RegExp(/^\s*state = (.*)$/, "m")
+
+    var user = child_process.spawnSync('id', ['-u']).stdout.toString()
+    var cmdResult = this.commandRunner.run('launchctl',
+      ['print', `user/${user}/com.github.gitbundleserver`])
+
+    this.parseOutput(cmdResult.stdout.toString(), regex)
+  }
+}
+
+export class SystemdDaemonState extends DaemonState {
+  get(): void {
+    var regex = new RegExp(/^\s*Active: (.*)(?= \()/, "m")
+
+    var user = child_process.spawnSync('id', ['-u']).stdout.toString()
+    var cmdResult = this.commandRunner.run('systemctl',
+        ['status', '--user', user, 'com.github.gitbundleserver'])
+
+    this.parseOutput(cmdResult.stdout.toString(), regex)
+  }
+}

test/integration/features/command.feature

@@ -0,0 +1,10 @@
+Feature: Bundle server commands
+  Scenario:
+    Given the daemon has not been started
+    When I run the 'git-bundle-server web-server start' command
+    Then the daemon is running
+
+  Scenario:
+    Given the daemon was started
+    When I run the 'git-bundle-server web-server stop' command
+    Then the daemon is not running

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 {string} command', async function (this: BundleServerWorld, command: string) {
+    this.run_command(command.split(' '))
+})

test/integration/features/step_definitions/daemon.ts

@@ -0,0 +1,34 @@
+import { After, Given, Then } from "@cucumber/cucumber"
+import { BundleServerWorld } from "../support/world"
+import * as daemonHelpers from "../support/daemonHelpers"
+
+Given('the daemon has not been started', async function (this: BundleServerWorld) {
+  var daemonState = this.getDaemonState()
+  if (daemonHelpers.isDaemonRunning(daemonState.status)) {
+    this.run_command(['git-bundle-server', 'web-server', 'stop'])
+  }
+})
+
+Given('the daemon was started', async function (this: BundleServerWorld) {
+  var daemonState = this.getDaemonState()
+  if (daemonHelpers.isDaemonRunning(daemonState.status)) {
+    this.run_command(['git-bundle-server', 'web-server', 'start'])
+  }
+})
+
+Then('the daemon is running', async function (this: BundleServerWorld) {
+  var daemonStatus = this.getDaemonState()
+  daemonHelpers.assertDaemonStatus(daemonHelpers.DaemonStatusType.Running, daemonStatus.status)
+})
+
+Then('the daemon is not running', async function (this: BundleServerWorld) {
+  var daemonStatus = this.getDaemonState()
+  daemonHelpers.assertDaemonStatus(daemonHelpers.DaemonStatusType.NotRunning, daemonStatus.status)
+})
+
+After(function (this: BundleServerWorld) {
+  var daemonState = this.getDaemonState()
+  if (daemonHelpers.isDaemonRunning(daemonState.status)) {
+    this.run_command(['git-bundle-server', 'web-server', 'stop'])
+  }
+});

test/integration/features/support/daemonHelpers.ts

@@ -0,0 +1,73 @@
+import * as assert from 'assert'
+import * as path from 'path'
+
+// launchd/launchctl
+const launchctlDaemonRunningStatus = 'running'
+const launchctlDaemonNotRunningStatus = 'not running'
+
+// systemd/systemctl
+const systemctlDaemonRunningStatus = 'active'
+const systemctlDaemonNotRunningStatus = 'inactive'
+
+export function absPath(pathParam: string): string {
+  // Convert a given path (either relative to 'test/integration/' or absolute) to an
+  // absolute path
+  if (!path.isAbsolute(pathParam)) {
+    return path.resolve(__dirname, "../..", pathParam)
+  } else {
+    return pathParam
+  }
+}
+
+export enum DaemonStatusType {
+  Running = 1,
+  NotRunning = 2
+}
+
+export function isDaemonRunning(status: string | null) {
+  switch(process.platform) {
+    case "darwin":
+      if (status === launchctlDaemonRunningStatus) {
+        return true
+      }
+      else {
+        return false
+      }
+    case "linux":
+      if (status === systemctlDaemonRunningStatus) {
+        return true
+      }
+      else {
+        return false
+      }
+    }
+}
+
+export function assertDaemonStatus(
+  statusType: DaemonStatusType,
+  actual: string | null): void {
+  var expected = ''
+
+  switch(process.platform) {
+    case "darwin":
+      if (statusType === DaemonStatusType.Running) {
+        expected = launchctlDaemonRunningStatus
+      }
+      else {
+        expected = launchctlDaemonNotRunningStatus
+      }
+      break
+    case "linux":
+      if (statusType === DaemonStatusType.Running) {
+        expected = systemctlDaemonRunningStatus
+      }
+      else {
+        expected = systemctlDaemonNotRunningStatus
+      }
+      break
+    default:
+      throw new Error("Unrecognized platform")
+  }
+
+  assert.strictEqual(actual, expected)
+}

test/integration/features/support/utils.ts

@@ -1,4 +1,5 @@
 import * as path from 'path'
+import * as assert from 'assert'
 
 export function absPath(pathParam: string): string {
   // Convert a given path (either relative to 'test/integration/' or absolute) to an

test/integration/features/support/world.ts

@@ -1,5 +1,6 @@
 import { setWorldConstructor, World, IWorldOptions } from '@cucumber/cucumber'
 import { BundleServer } from '../classes/bundleServer'
+import { DaemonState, LaunchdDaemonState, SystemdDaemonState } from '../classes/DaemonState'
 
 interface BundleServerParameters {
   bundleServerCommand: string
@@ -19,6 +20,13 @@ export class BundleServerWorld extends World<BundleServerParameters> {
     args.shift()
     this.bundleServer.run_command(args)
   }
+
+  getDaemonState(): DaemonState {
+    if (process.platform === "darwin") {
+      return new LaunchdDaemonState()
+    }
+    return new SystemdDaemonState()
+  }
 }
 
 setWorldConstructor(BundleServerWorld)