jettypod 4.1.2 → 4.1.4

package/features/step_definitions/simplify-external-transition.steps.js

@@ -1,370 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const assert = require('assert');
-
-let testDir;
-let db;
-
-Given('I have a JettyPod project in internal state', function() {
-  // Create test directory
-  testDir = path.join(__dirname, '../../test-tmp', `external-transition-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-
-  // Change to test directory
-  process.chdir(testDir);
-
-  // Initialize JettyPod
-  execSync('node ' + path.join(__dirname, '../../jettypod.js') + ' init', { cwd: testDir });
-
-  // Verify internal state
-  const config = require('../../lib/config');
-  const projectConfig = config.read();
-  assert.strictEqual(projectConfig.project_state, 'internal');
-
-  // Get database connection
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-});
-
-Given('I have some features in stable mode with production chores already created', async function() {
-  // Create a feature in stable mode
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status, mode, phase) VALUES (?, ?, ?, ?, ?, ?)`,
-      ['feature', 'Test Feature', 'A test feature', 'done', 'stable', 'implementation'],
-      function(err) {
-        if (err) reject(err);
-        else {
-          const featureId = this.lastID;
-
-          // Create production chores for this feature
-          const productionChores = [
-            'Security hardening for Test Feature',
-            'Scale testing for Test Feature',
-            'Compliance requirements for Test Feature'
-          ];
-
-          let completed = 0;
-          productionChores.forEach(title => {
-            db.run(
-              `INSERT INTO work_items (type, title, parent_id, status, mode) VALUES (?, ?, ?, ?, ?)`,
-              ['chore', title, featureId, 'todo', 'production'],
-              (err) => {
-                if (err) reject(err);
-                completed++;
-                if (completed === productionChores.length) resolve();
-              }
-            );
-          });
-        }
-      }
-    );
-  });
-});
-
-Then('the project_state should be updated to {string}', function(expectedState) {
-  const config = require('../../lib/config');
-  const projectConfig = config.read();
-  assert.strictEqual(projectConfig.project_state, expectedState);
-});
-
-Then('an {string} epic should be created', function(epicTitle) {
-  return new Promise((resolve, reject) => {
-    db.get(
-      `SELECT * FROM work_items WHERE type = ? AND title = ?`,
-      ['epic', epicTitle],
-      (err, row) => {
-        if (err) reject(err);
-        assert.ok(row, `Epic "${epicTitle}" should exist`);
-        this.epicId = row.id;
-        resolve();
-      }
-    );
-  });
-});
-
-Then('{int} infrastructure features should be created under the epic', function(expectedCount) {
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE type = ? AND parent_id = ?`,
-      ['feature', this.epicId],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, expectedCount, `Should have ${expectedCount} features`);
-
-        // Verify feature titles match expected categories
-        const titles = rows.map(r => r.title);
-        assert.ok(titles.some(t => t.includes('Security')), 'Should have Security feature');
-        assert.ok(titles.some(t => t.includes('Monitoring')), 'Should have Monitoring feature');
-        assert.ok(titles.some(t => t.includes('Infrastructure')), 'Should have Infrastructure feature');
-        assert.ok(titles.some(t => t.includes('Compliance')), 'Should have Compliance feature');
-
-        this.featureIds = rows.map(r => r.id);
-        resolve();
-      }
-    );
-  });
-});
-
-Then('{int} infrastructure chores should be created across the features', function(expectedCount) {
-  return new Promise((resolve, reject) => {
-    const placeholders = this.featureIds.map(() => '?').join(',');
-    db.all(
-      `SELECT * FROM work_items WHERE type = ? AND parent_id IN (${placeholders})`,
-      ['chore', ...this.featureIds],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, expectedCount, `Should have ${expectedCount} chores`);
-        resolve();
-      }
-    );
-  });
-});
-
-Then('production mode work items should now be visible in the backlog', function() {
-  // Verify that production items would be visible
-  // This is tested by checking that the state allows them to show
-  const config = require('../../lib/config');
-  const projectConfig = config.read();
-  assert.strictEqual(projectConfig.project_state, 'external', 'External state enables production visibility');
-
-  // Verify production chores exist
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE mode = ?`,
-      ['production'],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.ok(rows.length > 0, 'Production items should exist');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('no duplicate production chores should be created for existing features', function() {
-  return new Promise((resolve, reject) => {
-    // Check that we only have the 3 production chores we created in setup
-    // plus the infrastructure chores (which are not duplicates)
-    db.all(
-      `SELECT * FROM work_items WHERE mode = ? AND title LIKE ?`,
-      ['production', '%Test Feature%'],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 3, 'Should only have the original 3 production chores for Test Feature');
-        resolve();
-      }
-    );
-  });
-});
-
-// STABLE MODE: Error handling and edge case step definitions
-
-Given('I have a JettyPod project in external state', function() {
-  // Create test directory
-  testDir = path.join(__dirname, '../../test-tmp', `external-transition-${Date.now()}`);
-  fs.mkdirSync(testDir, { recursive: true });
-
-  // Change to test directory
-  process.chdir(testDir);
-
-  // Initialize JettyPod
-  execSync('node ' + path.join(__dirname, '../../jettypod.js') + ' init', { cwd: testDir });
-
-  // Update to external state
-  const config = require('../../lib/config');
-  config.update({ project_state: 'external' });
-
-  // Verify external state
-  const projectConfig = config.read();
-  assert.strictEqual(projectConfig.project_state, 'external');
-
-  // Get database connection
-  const { getDb } = require('../../lib/database');
-  db = getDb();
-});
-
-Given('an {string} epic already exists', async function(epicTitle) {
-  // Create the epic manually
-  await new Promise((resolve, reject) => {
-    db.run(
-      `INSERT INTO work_items (type, title, description, status) VALUES (?, ?, ?, ?)`,
-      ['epic', epicTitle, 'Existing infrastructure epic', 'todo'],
-      function(err) {
-        if (err) reject(err);
-        else {
-          this.existingEpicId = this.lastID;
-          resolve();
-        }
-      }
-    );
-  });
-});
-
-Given('the database connection will fail', function() {
-  // Mock database failure - we'll implement this by closing the db
-  this.shouldFailDatabase = true;
-  if (db) {
-    db.close();
-    db = null;
-  }
-});
-
-Given('work item creation will fail after creating the epic', function() {
-  // This will be tested by mocking the create function
-  this.shouldFailAfterEpic = true;
-});
-
-Given('the infrastructure checklist has invalid data', function() {
-  // Mock invalid checklist data - we'll test this by modifying the checklist temporarily
-  this.shouldHaveInvalidChecklist = true;
-});
-
-Then('I should see a message {string}', function(expectedMessage) {
-  assert.ok(this.output, 'Should have output');
-  assert.ok(this.output.includes(expectedMessage), `Output should contain "${expectedMessage}". Got: ${this.output}`);
-});
-
-Then('no duplicate infrastructure items should be created', function() {
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE type = 'epic' AND title = 'Infrastructure Readiness'`,
-      [],
-      (err, rows) => {
-        if (err) reject(err);
-        // Should have at most 1 epic
-        assert.ok(rows.length <= 1, 'Should not have duplicate Infrastructure Readiness epics');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('the command should exit successfully', function() {
-  assert.ok(!this.error || this.error.status === 0, 'Command should exit successfully');
-});
-
-Then('no duplicate {string} epic should be created', function(epicTitle) {
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE type = 'epic' AND title = ?`,
-      [epicTitle],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 1, `Should only have one "${epicTitle}" epic`);
-        resolve();
-      }
-    );
-  });
-});
-
-Then('existing infrastructure items should be preserved', function() {
-  return new Promise((resolve, reject) => {
-    if (!this.existingEpicId) {
-      return resolve(); // No existing items to check
-    }
-
-    db.get(
-      `SELECT * FROM work_items WHERE id = ?`,
-      [this.existingEpicId],
-      (err, row) => {
-        if (err) reject(err);
-        assert.ok(row, 'Existing epic should still exist');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('I should see a message about existing infrastructure', function() {
-  assert.ok(this.output, 'Should have output');
-  assert.ok(
-    this.output.includes('infrastructure') || this.output.includes('existing') || this.output.includes('already'),
-    'Output should mention existing infrastructure'
-  );
-});
-
-Then('I should see a clear error message about database failure', function() {
-  assert.ok(this.error || this.output.includes('error'), 'Should have error output');
-  const errorText = this.error ? (this.error.message || this.error.stderr || this.error.stdout) : this.output;
-  assert.ok(
-    errorText.toLowerCase().includes('database') || errorText.toLowerCase().includes('connection'),
-    'Error should mention database or connection'
-  );
-});
-
-Then('the project_state should remain {string}', function(expectedState) {
-  const config = require('../../lib/config');
-  const projectConfig = config.read();
-  assert.strictEqual(projectConfig.project_state, expectedState);
-});
-
-Then('no partial infrastructure items should be created', function() {
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE title LIKE '%Infrastructure%' OR title LIKE '%Security%' OR title LIKE '%Monitoring%' OR title LIKE '%Compliance%'`,
-      [],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 0, 'Should not have any infrastructure items created');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('I should see an error message about failed creation', function() {
-  assert.ok(this.error || this.output.includes('error'), 'Should have error output');
-  const errorText = this.error ? (this.error.message || this.error.stderr || this.error.stdout) : this.output;
-  assert.ok(
-    errorText.toLowerCase().includes('fail') || errorText.toLowerCase().includes('error'),
-    'Error should mention failure'
-  );
-});
-
-Then('any partial work items should be cleaned up', function() {
-  // Verify that if epic was created, it's been rolled back
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE type = 'epic' AND title = 'Infrastructure Readiness'`,
-      [],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 0, 'Partial epic should be cleaned up');
-        resolve();
-      }
-    );
-  });
-});
-
-Then('I should see a validation error message', function() {
-  assert.ok(this.error || this.output.includes('error'), 'Should have error output');
-  const errorText = this.error ? (this.error.message || this.error.stderr || this.error.stdout) : this.output;
-  assert.ok(
-    errorText.toLowerCase().includes('invalid') || errorText.toLowerCase().includes('validation'),
-    'Error should mention validation or invalid data'
-  );
-});
-
-Then('no infrastructure items should be created', function() {
-  return new Promise((resolve, reject) => {
-    db.all(
-      `SELECT * FROM work_items WHERE title LIKE '%Infrastructure%' OR title LIKE '%Security%' OR title LIKE '%Monitoring%' OR title LIKE '%Compliance%'`,
-      [],
-      (err, rows) => {
-        if (err) reject(err);
-        assert.strictEqual(rows.length, 0, 'Should not have any infrastructure items');
-        resolve();
-      }
-    );
-  });
-});
-
-// Cleanup
-process.on('exit', () => {
-  if (testDir && fs.existsSync(testDir)) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});

package/features/step_definitions/terminal-logo.steps.js

@@ -1,145 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const assert = require('assert');
-const path = require('path');
-const fs = require('fs');
-
-Given('the logo module exists', function () {
-  const logoPath = path.join(__dirname, '../../lib/logo.js');
-  assert(fs.existsSync(logoPath), `Logo module should exist at ${logoPath}`);
-  this.logoPath = logoPath;
-});
-
-When('I import it', function () {
-  // Import the logo module
-  this.logoModule = require(this.logoPath);
-});
-
-Then('it exports a {string} function', function (functionName) {
-  assert(this.logoModule, 'Logo module should be imported');
-  assert(typeof this.logoModule[functionName] === 'function', `Should export a ${functionName} function`);
-  this.exportedFunction = this.logoModule[functionName];
-});
-
-When('I call the showLogo function', function () {
-  // Capture console.log output
-  const originalLog = console.log;
-  const logOutput = [];
-
-  console.log = (...args) => {
-    logOutput.push(args.join(' '));
-  };
-
-  try {
-    // Call the showLogo function
-    const { showLogo } = require('../../lib/logo.js');
-    showLogo();
-  } finally {
-    console.log = originalLog;
-  }
-
-  this.logoOutput = logOutput;
-});
-
-Then('it outputs {int} lines of logo art', function (expectedLines) {
-  assert(this.logoOutput, 'Logo output should exist');
-  // Count total lines across all console.log calls (split by newlines)
-  const totalLines = this.logoOutput.reduce((count, output) => {
-    return count + output.split('\n').filter(line => line.trim().length > 0).length;
-  }, 0);
-  assert(totalLines >= expectedLines,
-    `Expected at least ${expectedLines} lines but got ${totalLines}`);
-});
-
-Then('it includes the version subtitle', function () {
-  assert(this.logoOutput, 'Logo output should exist');
-  const hasVersionLine = this.logoOutput.some(line =>
-    line.includes('version') || line.includes('v') || line.includes('.')
-  );
-  assert(hasVersionLine, 'Logo should include version subtitle');
-});
-
-When('I run jettypod init', function () {
-  const { execSync } = require('child_process');
-  const jettypodPath = path.join(__dirname, '../../jettypod.js');
-  const skillsSourceDir = path.join(__dirname, '../../.claude/skills');
-
-  try {
-    const output = execSync(`node ${jettypodPath} init`, {
-      cwd: this.testDir || process.cwd(),
-      encoding: 'utf-8',
-      env: { ...process.env, JETTYPOD_SKILLS_SOURCE_DIR: skillsSourceDir }
-    });
-    this.initOutput = output;
-  } catch (err) {
-    this.initOutput = err.stdout || '';
-    this.initError = err;
-  }
-});
-
-Then('the output contains the unicode gradient logo', function () {
-  assert(this.initOutput || this.commandOutput, 'Should have output from jettypod init');
-  const output = this.initOutput || this.commandOutput;
-
-  // Check for DEV or POD in the output
-  const hasLogo = output.includes('DEV') || output.includes('POD') ||
-                  output.includes('█') || output.includes('▓') ||
-                  output.includes('▒') || output.includes('░');
-
-  assert(hasLogo, 'Output should contain unicode gradient logo characters');
-});
-
-Then('I see the unicode logo', function () {
-  assert(this.initOutput || this.commandOutput, 'Should have output from jettypod init');
-  const output = this.initOutput || this.commandOutput;
-
-  const hasLogo = output.includes('DEV') || output.includes('POD') ||
-                  output.includes('█') || output.includes('▓');
-
-  assert(hasLogo, 'Should see unicode logo in output');
-});
-
-Then('the logo includes {string} and {string} text', function (text1, text2) {
-  const output = this.initOutput || this.commandOutput;
-  assert(output, 'Should have output');
-  // The logo uses box-drawing characters, not literal text
-  // Just check that the output has the box characters that form the logo
-  const hasBoxChars = output.includes('█') || output.includes('╔') || output.includes('║');
-  assert(hasBoxChars, `Logo should include box-drawing characters (forms ${text1} and ${text2})`);
-});
-
-Then('the logo uses ANSI color codes', function () {
-  const output = this.initOutput || this.commandOutput;
-  assert(output, 'Should have output');
-
-  // Check for ANSI escape codes
-  const hasAnsiCodes = output.includes('\x1b[') || output.includes('\u001b[');
-  assert(hasAnsiCodes, 'Logo should use ANSI color codes');
-});
-
-Then('the .jettypod directory is created', function () {
-  const jettypodDir = path.join(this.testDir || process.cwd(), '.jettypod');
-  assert(fs.existsSync(jettypodDir), '.jettypod directory should be created');
-
-  // Verify it contains expected files
-  const configPath = path.join(jettypodDir, 'config.json');
-  assert(fs.existsSync(configPath), 'config.json should exist in .jettypod directory');
-});
-
-Then('git hooks are installed', function () {
-  const hooksDir = path.join(this.testDir || process.cwd(), '.git', 'hooks');
-
-  // Check if .git directory exists (it might not if init was run without git)
-  const gitDir = path.join(this.testDir || process.cwd(), '.git');
-  if (!fs.existsSync(gitDir)) {
-    // Skip this check if not a git repo
-    return;
-  }
-
-  // Check for post-commit hook
-  const postCommitHook = path.join(hooksDir, 'post-commit');
-  assert(fs.existsSync(postCommitHook), 'post-commit hook should be installed');
-
-  // Check for post-merge hook
-  const postMergeHook = path.join(hooksDir, 'post-merge');
-  assert(fs.existsSync(postMergeHook), 'post-merge hook should be installed');
-});

package/features/step_definitions/update-command.steps.js

@@ -1,183 +0,0 @@
-const { Given, When, Then } = require('@cucumber/cucumber');
-const assert = require('assert');
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const testDir = path.join('/tmp', 'jettypod-update-test-' + Date.now());
-let originalDir;
-let testContext = {};
-
-Given('jettypod version {float}.{int}.{int} is installed', function (major, minor, patch) {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  // Store version for later checks
-  testContext.currentVersion = `${major}.${minor}.${patch}`;
-});
-
-Given('npm registry has version {float}.{int}.{int} available', function (major, minor, patch) {
-  testContext.registryVersion = `${major}.${minor}.${patch}`;
-  // In a real implementation, we'd mock the npm registry
-  // For now, just store the expected version
-});
-
-Given('jettypod is installed', function () {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-});
-
-Given('there is no internet connection', function () {
-  testContext.noInternet = true;
-  // We'll simulate this in the When step
-});
-
-Given('I am in a directory without .claude\\/', function () {
-  originalDir = process.cwd();
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  fs.mkdirSync(testDir, { recursive: true });
-  process.chdir(testDir);
-
-  // Initialize git for the project
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-});
-
-When('I run update command {string}', async function (command) {
-  const args = command.replace('jettypod ', '').trim();
-
-  if (args === 'update') {
-    // Run update command with mocked dependencies
-    const updateCommand = require('../../features/update-command');
-    const originalConsoleLog = console.log;
-    const originalConsoleError = console.error;
-    let output = '';
-
-    console.log = (...args) => {
-      output += args.join(' ') + '\n';
-    };
-    console.error = (...args) => {
-      output += args.join(' ') + '\n';
-    };
-
-    try {
-      const mockOptions = {
-        getCurrentVersion: () => testContext.currentVersion || '3.0.0',
-        getLatestVersion: async () => {
-          if (testContext.noInternet) {
-            throw new Error('network error');
-          }
-          return testContext.registryVersion || '3.0.0';
-        },
-        updateJettyPod: (version) => {
-          output += `📦 Installing jettypod@${version}...\n`;
-          return true;
-        }
-      };
-
-      await updateCommand.runUpdate(mockOptions);
-      testContext.exitCode = 0;
-    } catch (err) {
-      output += err.message + '\n';
-      testContext.exitCode = 1;
-    } finally {
-      console.log = originalConsoleLog;
-      console.error = originalConsoleError;
-    }
-
-    testContext.output = output;
-  } else {
-    // Run other commands normally (init, etc)
-    try {
-      const skillsSourceDir = path.join(originalDir, '.claude', 'skills');
-      const output = execSync(
-        `node ${path.join(originalDir, 'jettypod.js')} ${args}`,
-        {
-          cwd: testDir,
-          encoding: 'utf-8',
-          env: { ...process.env, JETTYPOD_SKILLS_SOURCE_DIR: skillsSourceDir }
-        }
-      );
-      testContext.output = output;
-      testContext.exitCode = 0;
-    } catch (err) {
-      testContext.output = err.stdout || err.stderr || err.message;
-      testContext.exitCode = err.status || 1;
-    }
-  }
-});
-
-Then('jettypod checks npm registry for latest version', function () {
-  // This is implementation detail - can't easily test without mocking
-  // Just verify the command ran
-  assert(testContext.output, 'Command should produce output');
-});
-
-Then('jettypod shows {string}', function (expectedMessage) {
-  assert(testContext.output.includes(expectedMessage),
-    `Output should contain: ${expectedMessage}\nActual output: ${testContext.output}`);
-});
-
-Then('jettypod downloads and installs version {float}.{int}.{int}', function (major, minor, patch) {
-  // This would require mocking npm install
-  // For now, just check the command attempted to update
-  assert(testContext.exitCode === 0 || testContext.output.includes('update'),
-    'Should attempt to update');
-});
-
-Then('skills are refreshed in current project', function () {
-  // Check that skills directory exists or was attempted to be refreshed
-  const skillsDir = path.join(testDir, '.claude', 'skills');
-  // After update, skills should be present (if .claude exists) or attempted
-  // This is satisfied if update command ran successfully
-  assert(testContext.output, 'Update command should run');
-});
-
-Then('jettypod initializes the project', function () {
-  assert(testContext.exitCode === 0, 'Init should succeed');
-  assert(testContext.output.includes('JettyPod initialized') ||
-         testContext.output.includes('CLAUDE.md'),
-    'Should show initialization message');
-});
-
-Then('.claude\\/ directory is created', function () {
-  const claudeDir = path.join(testDir, '.claude');
-  assert(fs.existsSync(claudeDir), '.claude directory should exist');
-});
-
-Then('CLAUDE.md is created', function () {
-  // Use this.testDir if set by another step file, otherwise use local testDir or cwd
-  const dir = this.testDir || testDir || process.cwd();
-  const claudeMd = path.join(dir, 'CLAUDE.md');
-  assert(fs.existsSync(claudeMd), 'CLAUDE.md should exist');
-});
-
-Then('skills are installed', function () {
-  const skillsDir = path.join(testDir, '.claude', 'skills');
-  assert(fs.existsSync(skillsDir), 'Skills directory should exist');
-
-  // Cleanup after all checks
-  if (originalDir && testDir && fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    process.chdir(originalDir);
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-});
-
-Then('skills are still refreshed in current project using existing jettypod', function () {
-  // Even without network, skills should be refreshed from local jettypod
-  assert(testContext.output, 'Command should produce output');
-});