@programinglive/dev-workflow-mcp-server 1.8.1 → 1.9.1

package/tests/build.test.js

@@ -1,74 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { readFile, access } from 'fs/promises';
-import { exec as execCallback } from 'child_process';
-import { promisify } from 'util';
-import path from 'path';
-
-const exec = promisify(execCallback);
-
-test('build generates dist/index.mjs file', async () => {
-  const { stderr } = await exec('npx cross-env NODE_ENV=development npm run build:server');
-  // Allow the known vite warning about node:process
-  const knownWarning = '[plugin vite:resolve] Module "node:process" has been externalized for browser compatibility';
-  const tailwindOutput = '≈ tailwindcss';
-  const browserslistWarning = 'Browserslist: caniuse-lite is outdated';
-  const actualStderr = stderr.replace(/\x1B\[[0-9;]*m/g, ''); // Remove ANSI codes
-  assert(
-    actualStderr === '' || actualStderr.includes(knownWarning) || actualStderr.includes(tailwindOutput) || actualStderr.includes(browserslistWarning),
-    `Build should not have unexpected errors: ${actualStderr}`
-  );
-
-  // Verify the file exists
-  const distPath = path.join(process.cwd(), 'dist', 'index.mjs');
-  await access(distPath);
-
-  // Verify it contains expected content
-  const content = await readFile(distPath, 'utf-8');
-  assert(content.includes('main'), 'Bundle should contain main function');
-  assert(content.length > 1000, 'Bundle should be substantial');
-});
-
-test('build script exists in package.json', async () => {
-  const packagePath = path.join(process.cwd(), 'package.json');
-  const content = await readFile(packagePath, 'utf-8');
-  const pkg = JSON.parse(content);
-
-  assert.strictEqual(typeof pkg.scripts['build:server'], 'string');
-  assert(pkg.scripts['build:server'].includes('vite build'));
-});
-
-test('Hero component fetches npm downloads directly', async () => {
-  const heroPath = path.join(process.cwd(), 'web', 'components', 'Hero.tsx');
-  const heroContent = await readFile(heroPath, 'utf-8');
-
-  // Verify it fetches npm downloads directly from npm API
-  assert(heroContent.includes('api.npmjs.org'), 'Hero should fetch downloads from npm API');
-  assert(heroContent.includes('useState<string | null>(null)'), 'Hero should have version state');
-});
-
-test('Netlify deployment configuration exists for static export', async () => {
-  const netlifyTomlPath = path.join(process.cwd(), 'web', 'netlify.toml');
-  await access(netlifyTomlPath);
-  
-  const content = await readFile(netlifyTomlPath, 'utf-8');
-  assert(content.includes('[build]'), 'netlify.toml should have build section');
-  assert(content.includes('npm run build'), 'netlify.toml should have build command');
-  assert(content.includes('publish = "out"'), 'netlify.toml should publish out directory for static export');
-});
-
-test('Web package.json does not include better-sqlite3', async () => {
-  const webPackagePath = path.join(process.cwd(), 'web', 'package.json');
-  const content = await readFile(webPackagePath, 'utf-8');
-  const pkg = JSON.parse(content);
-  
-  assert(!pkg.dependencies['better-sqlite3'], 'Web should not depend on better-sqlite3 for Netlify compatibility');
-});
-
-test('Next.js config uses static export for Netlify', async () => {
-  const nextConfigPath = path.join(process.cwd(), 'web', 'next.config.ts');
-  const content = await readFile(nextConfigPath, 'utf-8');
-  
-  assert(content.includes("output: 'export'"), 'next.config.ts should use static export');
-  assert(content.includes('unoptimized: true'), 'next.config.ts should disable image optimization for static export');
-});

package/tests/db-adapters.test.js

@@ -1,108 +0,0 @@
-import "dotenv/config";
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import fs from "node:fs/promises";
-import os from "node:os";
-
-import { SqliteAdapter } from "../db/adapters/sqlite.js";
-import { MysqlAdapter } from "../db/adapters/mysql.js";
-import { PostgresAdapter } from "../db/adapters/postgres.js";
-
-
-// Helper to run common adapter tests
-async function runGenericAdapterTests(t, adapter, testUserId, testProject) {
-    await t.test("connects and migrates", async () => {
-        await adapter.connect();
-        // No error means success
-    });
-
-    await t.test("inserts and retrieves history", async () => {
-        const entry = {
-            taskDescription: "Test Task",
-            taskType: "feature",
-            commitMessage: "feat: test",
-            timestamp: new Date().toISOString(),
-        };
-        await adapter.insertHistoryEntry(testUserId, testProject, entry);
-
-        const history = await adapter.getHistoryForUser(testUserId, testProject, { pageSize: 1 });
-        assert.equal(history.entries.length, 1);
-        assert.equal(history.entries[0].task_description, "Test Task");
-    });
-
-    await t.test("saves and retrieves state", async () => {
-        const state = { phase: "testing", count: 123 };
-        await adapter.saveState(testUserId, testProject, state);
-        const retrieved = await adapter.getState(testUserId, testProject);
-        assert.deepEqual(retrieved, state);
-    });
-
-    await t.test("history summary aggregation", async () => {
-        // already inserted one entry
-        const summary = await adapter.getHistorySummary(testUserId, testProject, { frequency: 'daily' });
-        assert.ok(summary.length > 0);
-    });
-
-    await t.test("project summary update", async () => {
-        const summary = await adapter.getSummaryForUser(testUserId, testProject);
-        assert.ok(summary);
-        assert.ok(summary.totalTasks >= 1);
-    });
-}
-
-test("Database Adapters", async (t) => {
-    // 1. SQLite (Always Test)
-    await t.test("SqliteAdapter", async (t) => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "sqlite-test-"));
-        const dbPath = path.join(tmpDir, "test.db");
-
-        // Convert to file URI for connection string if needed, or just pass path
-        // The adapter expects a connection URL for SQLite usually: file:///path/to/db or just path?
-        // Looking at sqlite.js: uri: this.config.connectionUrl.replace("sqlite://", "")
-        // So we invoke it with sqlite://<path>
-        const connectionUrl = `sqlite://${dbPath}`;
-
-        const adapter = new SqliteAdapter({ connectionUrl });
-
-        try {
-            await runGenericAdapterTests(t, adapter, "user-sqlite", tmpDir);
-        } finally {
-            if (adapter.db) adapter.db.close();
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-
-    // 2. MySQL (Conditional)
-    // Check specific test variable OR generic one if it maps to mysql
-    const mysqlUrl = process.env.TEST_MYSQL_URL ||
-        (process.env.DEV_WORKFLOW_DB_URL && process.env.DEV_WORKFLOW_DB_URL.startsWith("mysql") ? process.env.DEV_WORKFLOW_DB_URL : null);
-
-    await t.test("MysqlAdapter", { skip: !mysqlUrl }, async (t) => {
-        const adapter = new MysqlAdapter({ connectionUrl: mysqlUrl });
-        try {
-            // We use a random user ID to avoid clashing with verification script data
-            // although verification cleaned up mostly.
-            const testId = `test-mysql-${Date.now()}`;
-            const testProj = process.cwd();
-            await runGenericAdapterTests(t, adapter, testId, testProj);
-        } finally {
-            if (adapter.pool) await adapter.pool.end();
-        }
-    });
-
-    // 3. PostgreSQL (Conditional)
-    const pgUrl = process.env.TEST_POSTGRES_URL ||
-        (process.env.DEV_WORKFLOW_DB_URL && process.env.DEV_WORKFLOW_DB_URL.startsWith("postgres") ? process.env.DEV_WORKFLOW_DB_URL : null);
-
-    await t.test("PostgresAdapter", { skip: !pgUrl }, async (t) => {
-        const adapter = new PostgresAdapter({ connectionUrl: pgUrl });
-        try {
-            const testId = `test-pg-${Date.now()}`;
-            const testProj = process.cwd();
-            await runGenericAdapterTests(t, adapter, testId, testProj);
-        } finally {
-            if (adapter.pool) await adapter.pool.end();
-        }
-    });
-});

package/tests/env-support.test.js

@@ -1,46 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import path from "node:path";
-import fs from "node:fs/promises";
-import os from "node:os";
-import { exec } from "node:child_process";
-import { promisify } from "node:util";
-import { pathToFileURL } from "node:url";
-
-const execAsync = promisify(exec);
-
-test("Environment Configuration", async (t) => {
-    await t.test("loads variables from .env file", async () => {
-        const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "env-test-"));
-        const originalCwd = process.cwd();
-        const indexJsPath = path.resolve(originalCwd, "index.js");
-        const indexUrl = pathToFileURL(indexJsPath).href;
-
-        try {
-            // Create a .env file
-            await fs.writeFile(path.join(tmpDir, ".env"), "TEST_ENV_VAR=loaded_successfully");
-
-            // Verify node can run and load it via index.js import
-            // We import index.js to trigger the 'dotenv/config' import.
-            // Since index.js starts a server if run directly, we just import it.
-            // However, we need to run a script in the NEW CWD.
-
-            const script = `
-        import '${indexUrl}'; 
-        console.log("VAR:" + process.env.TEST_ENV_VAR);
-        process.exit(0);
-      `;
-
-            const scriptPath = path.join(tmpDir, "check_env.js");
-            await fs.writeFile(scriptPath, script);
-
-            // Execute in tmpDir
-            const { stdout } = await execAsync(`node check_env.js`, { cwd: tmpDir });
-
-            assert.ok(stdout.includes("VAR:loaded_successfully"), "Output should contain loaded variable");
-
-        } finally {
-            await fs.rm(tmpDir, { recursive: true, force: true });
-        }
-    });
-});

package/tests/exec.test.js

@@ -1,35 +0,0 @@
-import { test } from 'node:test';
-import assert from 'node:assert';
-import { exec } from '../exec.js';
-import { tmpdir } from 'os';
-import { mkdtemp, rm } from 'fs/promises';
-import path from 'path';
-
-test('exec runs commands successfully', async () => {
-  const echoCommand = process.platform === 'win32' ? 'echo hello world' : 'echo "hello world"';
-  const { stdout } = await exec(echoCommand);
-  const normalized = stdout.trim().replace(/^"(.*)"$/, '$1');
-  assert.strictEqual(normalized, 'hello world');
-});
-
-test('exec respects explicit cwd option', async () => {
-  const tempDir = await mkdtemp(path.join(tmpdir(), 'mcp-test-'));
-  
-  try {
-    const dirCommand = process.platform === 'win32' ? 'cd' : 'pwd';
-    const { stdout } = await exec(dirCommand, { cwd: tempDir });
-    // Just verify it runs in the specified directory (path may vary by platform)
-    assert(stdout.trim().toLowerCase().includes('mcp-test-'));
-  } finally {
-    await rm(tempDir, { recursive: true, force: true });
-  }
-});
-
-test('exec handles command errors', async () => {
-  try {
-    await exec('command-that-does-not-exist');
-    assert.fail('Should have thrown an error');
-  } catch (error) {
-    assert(error.code !== undefined || error.message.includes('command-not-found'));
-  }
-});

package/tests/handlers-commit.test.js

@@ -1,174 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { handleToolCall } from "../tools/handlers.js";
-import { withWorkflowState, testUtils, createRequest, createGitMock } from "./test-helpers.js";
-
-test("commit_and_push commits changes and pushes", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.readyToCommit = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.testsSkipped = false;
-    workflowState.state.testsCreated = true;
-    workflowState.state.testsPassed = true;
-    workflowState.state.currentPhase = "commit";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("commit_and_push", { commitMessage: "" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        hasWorkingChanges: async () => true,
-        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
-        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-      }),
-      utils: testUtils,
-    });
-
-    const pushCommand = commands.find((command) => command.startsWith("git push"));
-    assert.ok(pushCommand, "git push should be executed during commit");
-    assert.ok(
-      pushCommand.startsWith("git push origin"),
-      "push command should target origin"
-    );
-    assert.equal(
-      commands.some((command) => command.startsWith("git commit")),
-      true,
-      "git commit should be executed"
-    );
-    assert.ok(
-      response.content[0].text.includes("Commit and push completed!"),
-      "response should confirm commit and push"
-    );
-    assert.equal(workflowState.state.commitAndPushCompleted, true);
-    assert.equal(workflowState.state.lastCommitMessage.length > 0, true);
-    assert.equal(workflowState.state.currentPhase, "release");
-  });
-});
-
-test("commit_and_push uses primary branch when no branch specified", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.readyToCommit = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.testsSkipped = false;
-    workflowState.state.testsCreated = true;
-    workflowState.state.testsPassed = true;
-    workflowState.state.currentPhase = "commit";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        hasWorkingChanges: async () => true,
-        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
-        getCurrentBranch: async () => "feature/test",
-        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-      }),
-      utils: testUtils,
-    });
-
-    const pushCommand = commands.find((command) => command.startsWith("git push"));
-    assert.ok(pushCommand, "git push should be executed");
-    assert.ok(
-      /origin\s+['"]?main['"]?/.test(pushCommand),
-      "push should use primary branch (main) when no branch specified"
-    );
-  });
-});
-
-test("commit_and_push falls back to master when main not found", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.readyToCommit = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.testsSkipped = false;
-    workflowState.state.testsCreated = true;
-    workflowState.state.testsPassed = true;
-    workflowState.state.currentPhase = "commit";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("commit_and_push", { commitMessage: "feat: test" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        hasWorkingChanges: async () => true,
-        getStagedChanges: async () => [{ status: "M", path: "src/index.js" }],
-        getPrimaryBranch: async () => "master",
-        getStatusOutput: async () => "M tests/handlers.test.js\nM src/index.js",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-      }),
-      utils: testUtils,
-    });
-
-    const pushCommand = commands.find((command) => command.startsWith("git push"));
-    assert.ok(pushCommand, "git push should be executed");
-    assert.ok(
-      /origin\s+['"]?master['"]?/.test(pushCommand),
-      "push should use master when main not found"
-    );
-  });
-});
-
-test("commit_and_push recognizes already committed work", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.readyToCommit = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.testsSkipped = false;
-    workflowState.state.testsCreated = true;
-    workflowState.state.testsPassed = true;
-    workflowState.state.currentPhase = "commit";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("commit_and_push", { commitMessage: "" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        hasWorkingChanges: async () => false,
-        getLastCommitMessage: async () => "fix: previous work",
-        getStatusOutput: async () => "",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-      }),
-      utils: testUtils,
-    });
-
-    assert.ok(
-      response.content[0].text.includes("No changes detected"),
-      "response should indicate no changes"
-    );
-    assert.equal(workflowState.state.commitAndPushCompleted, true);
-    assert.equal(workflowState.state.currentPhase, "release");
-  });
-});

package/tests/handlers-release.test.js

@@ -1,212 +0,0 @@
-import test from "node:test";
-import assert from "node:assert/strict";
-import { handleToolCall } from "../tools/handlers.js";
-import { withWorkflowState, testUtils, createRequest, createGitMock } from "./test-helpers.js";
-
-test("perform_release runs release command before pushing with tags", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.lastPushBranch = "feature/split";
-    workflowState.state.lastCommitMessage = "fix: address issue";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      if (command === "git status --porcelain") {
-        return { stdout: "" };
-      }
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("perform_release", { command: "npm run release" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock(),
-      utils: testUtils,
-    });
-
-    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
-    assert.ok(releaseCommand, "release command should run");
-    assert.ok(
-      commands.some((command) => command.startsWith("git push --follow-tags")),
-      "release should push tags"
-    );
-  });
-});
-
-test("perform_release accepts shorthand patch command", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.lastCommitMessage = "fix: adjust labels";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      if (command === "git status --porcelain") {
-        return { stdout: "" };
-      }
-      return { stdout: "" };
-    };
-
-    await handleToolCall({
-      request: createRequest("perform_release", { command: "patch" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock(),
-      utils: testUtils,
-    });
-
-    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
-    assert.ok(releaseCommand, "release command should run with patch");
-  });
-});
-
-test("perform_release respects explicit releaseType option", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = true;
-    workflowState.state.readyCheckCompleted = true;
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      if (command === "git status --porcelain") {
-        return { stdout: "" };
-      }
-      return { stdout: "" };
-    };
-
-    await handleToolCall({
-      request: createRequest("perform_release", {
-        command: "npm run release",
-        releaseType: "minor",
-      }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock(),
-      utils: testUtils,
-    });
-
-    const releaseCommand = commands.find((command) => command.startsWith("npm run release"));
-    assert.ok(releaseCommand, "release command should run");
-    assert.ok(
-      releaseCommand.includes("-- --release-as minor"),
-      "release command should append provided releaseType"
-    );
-  });
-});
-
-test("perform_release blocks when new changes detected", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = true;
-    workflowState.state.readyCheckCompleted = true;
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      if (command === "git status --porcelain") {
-        return { stdout: "?? new-file.js" };
-      }
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("perform_release", { command: "patch" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        hasWorkingChanges: async () => true,
-        getStatusOutput: async () => "?? new-file.js",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-        workingTreeSummary: () => ({ hasChanges: true, lines: ["?? new-file.js"] }),
-      }),
-      utils: testUtils,
-    });
-
-    assert.ok(
-      response.content[0].text.includes("run 'commit_and_push' again"),
-      "response should instruct to recommit"
-    );
-    assert.equal(workflowState.state.currentPhase, "commit");
-    assert.equal(workflowState.state.commitAndPushCompleted, false);
-  });
-});
-
-test("perform_release requires commit_and_push completion when tree is clean", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = false;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.lastPushBranch = "";
-    workflowState.state.lastCommitMessage = "";
-    await workflowState.save();
-
-    const commands = [];
-    const execStub = async (command) => {
-      commands.push(command);
-      return { stdout: "" };
-    };
-
-    const response = await handleToolCall({
-      request: createRequest("perform_release", { command: "npm run release" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: execStub,
-      git: createGitMock({
-        getLastCommitMessage: async () => "chore: already pushed",
-        getStatusOutput: async () => "",
-        containsTestFilesInStatus: (statusOutput) => statusOutput.includes("tests/"),
-      }),
-      utils: testUtils,
-    });
-
-    assert.ok(
-      response.content[0].text.includes("commit_and_push"),
-      "response should mention commit_and_push requirement"
-    );
-  });
-});
-
-test("skip_release records justification and advances to completion phase", async () => {
-  await withWorkflowState(async (workflowState) => {
-    workflowState.state.currentPhase = "release";
-    workflowState.state.commitAndPushCompleted = true;
-    workflowState.state.readyCheckCompleted = true;
-    workflowState.state.lastCommitMessage = "chore: docs";
-    workflowState.state.releaseSkipped = false;
-    workflowState.state.released = false;
-    workflowState.state.releaseCommand = "";
-    await workflowState.save();
-
-    const response = await handleToolCall({
-      request: createRequest("skip_release", { reason: "Python project – no npm release" }),
-      normalizeRequestArgs: (args) => ({ args, error: null }),
-      workflowState,
-      exec: async () => ({ stdout: "" }),
-      git: createGitMock(),
-      utils: testUtils,
-    });
-
-    const text = response.content[0].text;
-    assert.ok(text.includes("Release step skipped"), "response should mention release was skipped");
-    assert.equal(workflowState.state.releaseSkipped, true);
-    assert.equal(workflowState.state.releaseSkippedReason, "Python project – no npm release");
-    assert.equal(workflowState.state.releaseCommand, "(skipped)");
-    assert.equal(workflowState.state.currentPhase, "ready_to_complete");
-    assert.equal(workflowState.state.released, false);
-  });
-});