bard 2.0.0.beta → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 315f02fbb865e24647f358979a3f135d6a9b5fa58d27d447cc92cc9462ba80b6
-  data.tar.gz: 3fd528b19bbfb0edfeb3b05aff689a4c4bc52ef9c2ac218566b1c0be8e071ade
+  metadata.gz: 24a9ee78c591a6446ac1bb749225497c75470e12e4fe822d96e975870ac88152
+  data.tar.gz: 2b8ae0acbf1237b3312957128130f399a516a3a19d52d45f63c7b0677952e4f2
 SHA512:
-  metadata.gz: 464041788694b06f9ef754a01a5de77e198140ad738cc60a7596110f32044b0e8b73ebb405aa210b488ad269b64d3829d51b368cc297617b9c0c8bfc479126c6
-  data.tar.gz: c48d80a55fc37dd081cb6220919c9f3cef0f0356f75b8befcd8fd1dbf89e11619075f3db9b8ec7cdf387da9e80ee120b39a93b500c839ba816c627cea3dff6ae
+  metadata.gz: 55a1a4f6fcf3bf12201105974a619be5178c3c9c6367d8dccf2eef1e7e504880a869a6291dfb5024930e025f63d8cf2f22c8925cf5fc24f9e83d2aa85ed047ed
+  data.tar.gz: 5da5d707ceed5ca663e4a68cd4a2ba2afbb232052e4a0542a4e41a1badc0161ba4eda410195b717d21f8fdaea299af771afa6a19310d93b66915996e8579b5fa

data/.github/workflows/ci.yml

@@ -5,7 +5,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ "3.2", "3.3", "3.4" ]
+        ruby: [ "3.3", "3.4", "4.0" ]
 
     runs-on: ubuntu-latest
     steps:
@@ -34,5 +34,10 @@ jobs:
           done
           echo "DOCKER_HOST=tcp://127.0.0.1:8080" >> $GITHUB_ENV
 
+      - name: Build test container image
+        run: |
+          sudo podman pull ubuntu:24.04
+          sudo podman build -t bard-test-server -f spec/acceptance/docker/Dockerfile spec/acceptance/docker
+
       - name: Run tests
         run: bundle exec rake

data/CLAUDE.md

@@ -0,0 +1,76 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## What is Bard?
+
+Bard is a modular deployment CLI tool for Ruby applications. It provides:
+- SSH-based deployment via git pull
+- GitHub Pages static site deployment
+- Custom pluggable deployment strategies
+- Data syncing (database dumps and file rsync)
+- CI integration (GitHub Actions/Jenkins)
+- Server provisioning
+
+## Development Commands
+
+```bash
+# Install dependencies
+bundle install
+
+# Run all tests (RSpec + Cucumber)
+bundle exec rake
+
+# Run only RSpec tests
+bundle exec rspec
+
+# Run a single spec file
+bundle exec rspec spec/bard/target_spec.rb
+
+# Run a specific test by line number
+bundle exec rspec spec/bard/target_spec.rb:42
+
+# Run Cucumber features (slow - avoid full suite)
+bundle exec cucumber features/deploy.feature
+
+# Run bard from source
+bundle exec bin/bard
+```
+
+## Architecture
+
+### Core Classes
+
+- **`Bard::CLI`** (`lib/bard/cli.rb`) - Thor-based command dispatcher. Commands are modules in `lib/bard/cli/` included into CLI.
+- **`Bard::Config`** (`lib/bard/config.rb`) - DSL parser for `bard.rb` files. Manages targets and settings.
+- **`Bard::Target`** (`lib/bard/target.rb`) - Deployment destination with capabilities (ssh, ping, data). Supports dynamic strategy DSL via `method_missing`.
+- **`Bard::SSHServer`** (`lib/bard/ssh_server.rb`) - SSH connection details (user, host, port, gateway, ssh_key, env).
+- **`Bard::DeployStrategy`** (`lib/bard/deploy_strategy.rb`) - Base class for deployment strategies. Subclasses auto-register via Ruby's `inherited` hook.
+
+### Capability System
+
+Targets track enabled capabilities (`:ssh`, `:ping`, `:github_pages`, etc.). Commands call `require_capability!` to ensure the target supports the operation.
+
+### Strategy Auto-Registration
+
+Custom strategies subclass `DeployStrategy` and are automatically registered by class name:
+```ruby
+class Bard::DeployStrategy::Jets < DeployStrategy  # registers as :jets
+  def deploy; ...; end
+end
+```
+
+### File Organization
+
+- `lib/bard/cli/*.rb` - CLI command modules (deploy, data, ssh, etc.)
+- `lib/bard/ci/*.rb` - CI system integrations (github_actions, jenkins, local)
+- `lib/bard/deploy_strategy/*.rb` - Built-in strategies (ssh, github_pages)
+- `lib/bard/provision/*.rb` - Server provisioning modules
+- `spec/` - RSpec unit tests
+- `features/` - Cucumber integration tests
+
+## Testing Notes
+
+- Use `focus: true` in RSpec to run specific tests
+- Cucumber tests use testcontainers and are slow - run specific feature files only
+- SimpleCov tracks coverage across both RSpec and Cucumber runs

data/MIGRATION_GUIDE.md

@@ -2,6 +2,8 @@
 
 This guide will help you migrate your Bard configuration from v1.x to v2.0.
 
+> **Note:** Bard v1.8.0 is a transitional release that supports both v1.x and v2.0 APIs. When using deprecated v1.x patterns, you'll see deprecation warnings indicating what to change. This gives you time to migrate at your own pace while keeping your deployments working.
+
 ## Overview of Changes
 
 Bard v2.0 introduces a cleaner, more modular architecture:
@@ -477,22 +479,35 @@ mv bard.rb.backup bard.rb
 - Check [CUSTOM_STRATEGIES.md](CUSTOM_STRATEGIES.md) for strategy creation
 - Open an issue at https://github.com/botandrose/bard/issues
 
-## Transitional Release (v1.9.x)
+## Transitional Release (v1.8.0)
 
-A transitional release (v1.9.x) will support both v1 and v2 APIs simultaneously with deprecation warnings. This allows gradual migration.
+Bard v1.8.0 is a transitional release that supports both v1.x and v2.0 APIs simultaneously with deprecation warnings. This allows gradual migration.
 
-**Using v1.9.x:**
+**Using v1.8.0:**
 ```bash
 # Gemfile
-gem 'bard', '~> 1.9'
+gem 'bard', '~> 1.8'
 
 bundle update bard
 ```
 
-v1.9.x will:
-- Accept both `server` and `target` (with deprecation warning)
-- Accept both old and new SSH configuration styles
-- Show deprecation warnings for old API usage
-- Support full v2 API
+v1.8.0 will:
+- Accept both `server` and `target` (with deprecation warning for `server`)
+- Accept both old and new SSH configuration styles (with deprecation warnings for separate options)
+- Accept both old `strategy`/`option` calls and new direct strategy methods (with deprecation warnings)
+- Show deprecation warnings for all deprecated v1.x API usage
+- Support full v2.0 API
 
 This gives you time to migrate at your own pace while keeping your deployments working.
+
+### Deprecation Warnings
+
+When using deprecated patterns, you'll see warnings like:
+
+```
+[DEPRECATION] `server` is deprecated; use `target` instead (will be removed in v2.0) (called from bard.rb:3)
+[DEPRECATION] Separate SSH options are deprecated; pass as keyword arguments to `ssh` instead (will be removed in v2.0) (called from bard.rb:5)
+[DEPRECATION] `strategy` is deprecated; use the strategy method directly (will be removed in v2.0) (called from bard.rb:10)
+```
+
+These warnings help you identify what needs to change before upgrading to v2.0.

data/PLUGINS.md

@@ -0,0 +1,99 @@
+# Plugin Development
+
+Bard uses a plugin system to extend functionality. Plugins can add CLI commands, target methods, and config DSL methods.
+
+## Plugin Structure
+
+Plugins live in `lib/bard/plugins/` and are auto-loaded. Command classes auto-register when they subclass `Bard::Plugin::Command`:
+
+```ruby
+# lib/bard/plugins/my_plugin.rb
+require "bard/plugin"
+
+class Bard::CLI::MyPlugin < Bard::Plugin::Command
+  desc "mycommand", "Description of my command"
+  option :verbose, type: :boolean
+  def mycommand
+    puts "Hello from my plugin!"
+    puts config[:production].url
+  end
+end
+```
+
+That's it — no registration block needed. The `Command` base class provides:
+- Automatic registration via Ruby's `inherited` hook
+- `desc` and `option` class methods for Thor integration
+- Delegation to the CLI instance (access to `config`, `project_name`, `run!`, `options`, etc.)
+
+## Extending Target and Config
+
+To add methods to `Bard::Target` or `Bard::Config`, reopen the class directly:
+
+```ruby
+# lib/bard/plugins/my_plugin.rb
+require "bard/target"
+
+class Bard::Target
+  def my_feature(url = nil)
+    if url.nil?
+      @my_feature_url
+    else
+      @my_feature_url = url
+      enable_capability(:my_feature)
+    end
+  end
+end
+
+require "bard/config"
+
+class Bard::Config
+  def my_global_setting(value = nil)
+    if value.nil?
+      @my_global_setting
+    else
+      @my_global_setting = value
+    end
+  end
+end
+```
+
+## Adding Strategies
+
+Plugins can add deployment strategies or CI runners:
+
+```ruby
+# Custom deploy strategy
+module Bard
+  class DeployStrategy
+    class MyCloud < DeployStrategy
+      def deploy
+        # Deployment logic here
+        run! "my-cloud deploy #{target.key}"
+      end
+    end
+  end
+end
+
+# Custom CI runner
+module Bard
+  class CI
+    class Runner
+      class MyCI < Runner
+        def run
+          # Start CI run
+        end
+
+        def status
+          # Return current status
+        end
+      end
+    end
+  end
+end
+```
+
+Strategies auto-register via Ruby's `inherited` hook. The class name determines the strategy key (e.g., `MyCloud` → `:my_cloud`).
+
+## Plugin Loading
+
+Plugins are loaded automatically from `lib/bard/plugins/`. The load order is alphabetical by filename. External plugins are loaded from the project's `lib/bard/plugins/` directory.

data/README.md

@@ -12,7 +12,7 @@ end
 ```
 
 ```bash
-bard deploy production
+bard deploy
 ```
 
 ## Features
@@ -115,17 +115,21 @@ end
 ### Deployment
 
 ```bash
-# Deploy to production
-bard deploy production
+# Deploy current branch to production (default)
+bard deploy
 
-# Deploy to staging
-bard deploy staging
+# Deploy a specific branch to production
+bard deploy feature-branch
+
+# Deploy to a different target
+bard deploy --target=staging
+bard deploy feature-branch --target=staging
 
 # Deploy feature branch to staging (no merge)
 bard stage feature-branch
 
 # Skip CI checks
-bard deploy production --skip-ci
+bard deploy --skip-ci
 ```
 
 ### Data Management
@@ -459,6 +463,10 @@ See [ARCHITECTURE.md](ARCHITECTURE.md) for detailed architecture documentation.
 
 See [CUSTOM_STRATEGIES.md](CUSTOM_STRATEGIES.md) for a step-by-step guide to creating custom deployment strategies.
 
+## Plugin Development
+
+See [PLUGINS.md](PLUGINS.md) for a guide to creating plugins.
+
 ## Development
 
 ```bash

data/Rakefile

@@ -1,7 +1,9 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "cucumber/rake/task"
 
 RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new(:cucumber)
 
-task :default => :spec
+task :default => [:spec, :cucumber]
 

data/bard.gemspec

@@ -15,11 +15,11 @@ Gem::Specification.new do |spec|
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = ["bard"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.required_ruby_version = ">= 3.3"
   spec.require_paths = ["lib"]
 
   spec.add_dependency "thor", ">= 0.19.0"
   spec.add_dependency "rvm"
-  spec.add_dependency "term-ansicolor", ">= 1.0.3"
   spec.add_dependency "rbnacl"
   spec.add_dependency "base64"
 
@@ -28,4 +28,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "debug"
   spec.add_development_dependency "cucumber"
   spec.add_development_dependency "testcontainers"
+  spec.add_development_dependency "ostruct"
 end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --publish-quiet

data/features/ci.feature

@@ -0,0 +1,63 @@
+@server
+Feature: bard ci
+  Run continuous integration tests.
+
+  Background:
+    Given a test server is running
+
+  Scenario: no CI configured error
+    When I run expecting failure: bard ci
+    Then the output should contain "No CI found"
+    And the output should contain "Re-run with --skip-ci to bypass CI"
+
+  Scenario: local CI runs successfully
+    Given a local CI script that passes
+    When I run: bard ci --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+
+  Scenario: local CI reports failure
+    Given a local CI script that fails with "Test failed: expected 1 but got 2"
+    When I run expecting failure: bard ci --local-ci
+    Then the output should contain "Test failed: expected 1 but got 2"
+    And the output should contain "Automated tests failed!"
+
+  Scenario: --ci option runs specified CI runner
+    Given a local CI script that passes
+    When I run: bard ci --ci=local
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+
+  Scenario: --ci option reports failure from specified runner
+    Given a local CI script that fails with "Custom runner failed"
+    When I run expecting failure: bard ci --ci=local
+    Then the output should contain "Custom runner failed"
+    And the output should contain "Automated tests failed!"
+
+  Scenario: deploy passes --ci option to CI
+    Given a local CI script that passes
+    And I create a file "ci-option-test.txt" with content "ci option test"
+    And I commit the changes with message "Add CI option test file"
+    When I run: bard deploy --ci=local
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+    And the output should contain "Deploy Succeeded"
+
+  Scenario: deploy runs CI before deploying
+    Given a local CI script that passes
+    And I create a file "ci-test.txt" with content "ci test"
+    And I commit the changes with message "Add CI test file"
+    When I run: bard deploy --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Continuous integration: success!"
+    And the output should contain "Deploy Succeeded"
+
+  Scenario: deploy aborts if CI fails
+    Given a local CI script that fails with "Build failed"
+    And I create a file "ci-fail.txt" with content "ci fail test"
+    And I commit the changes with message "Add CI fail test file"
+    When I run expecting failure: bard deploy --local-ci
+    Then the output should contain "Continuous integration: starting build"
+    And the output should contain "Build failed"
+    And the output should contain "Automated tests failed!"
+    And the output should not contain "Deploy Succeeded"

data/features/data.feature

@@ -0,0 +1,13 @@
+@server
+Feature: bard data
+  Copy database from a remote server to local.
+
+  Background:
+    Given a test server is running
+
+  Scenario: copies database from production to local
+    When I run: bard data
+    Then the output should contain "Dumping production database to file"
+    And the output should contain "Transfering file from production to local"
+    And the output should contain "Loading file into local database"
+    And a file "db/data.sql.gz" should exist locally

data/features/deploy.feature

@@ -0,0 +1,14 @@
+@server
+Feature: bard deploy
+  Deploy code changes to a remote server.
+
+  Background:
+    Given a test server is running
+
+  Scenario: deploys code changes to the remote server
+    Given I create a file "DEPLOYED.txt" with content "deployed by bard"
+    And I commit the changes with message "Add deployed marker"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    When I run: bard run "cat DEPLOYED.txt"
+    Then the output should contain "deployed by bard"

data/features/deploy_git_workflow.feature

@@ -0,0 +1,89 @@
+@server
+Feature: bard deploy git workflow
+  Git workflow behaviors during deploy.
+
+  Background:
+    Given a test server is running
+
+  Scenario: deploy on master pushes unpushed commits
+    Given I create a file "local-only.txt" with content "local commit"
+    And I commit the changes with message "Add local only file"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    When I run: bard run "cat local-only.txt"
+    Then the output should contain "local commit"
+
+  Scenario: feature branch fast-forward merge
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "feature-branch" should not exist locally
+    And branch "feature-branch" should not exist on origin
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+
+  Scenario: feature branch requires rebase
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And master has an additional commit from another source
+    When I run: bard deploy --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+    When I run: bard run "cat remote-change.txt"
+    Then the output should contain "remote change"
+
+  Scenario: feature branch rebase conflict
+    Given I create and switch to branch "feature-branch"
+    And I create a file "conflict.txt" with content "feature content"
+    And I commit the changes with message "Add conflicting file"
+    And master has a conflicting commit to "conflict.txt"
+    When I run expecting failure: bard deploy --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Running command failed"
+
+  Scenario: branch cleanup after deploy
+    Given I create and switch to branch "cleanup-test"
+    And I create a file "cleanup.txt" with content "cleanup test"
+    And I commit the changes with message "Add cleanup test file"
+    And I push branch "cleanup-test" to origin
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deleting branch: cleanup-test"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "cleanup-test" should not exist locally
+    And branch "cleanup-test" should not exist on origin
+
+  Scenario: deploy a branch without checking it out
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And I switch to branch "master"
+    When I run: bard deploy feature-branch --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    And branch "feature-branch" should not exist locally
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"
+
+  Scenario: deploy a branch that requires rebase without checking it out
+    Given I create and switch to branch "feature-branch"
+    And I create a file "feature.txt" with content "feature content"
+    And I commit the changes with message "Add feature"
+    And I switch to branch "master"
+    And master has an additional commit from another source
+    When I run: bard deploy feature-branch --skip-ci
+    Then the output should contain "The master branch has advanced"
+    And the output should contain "Attempting rebase"
+    And the output should contain "Deploy Succeeded"
+    And I should be on branch "master"
+    When I run: bard run "cat feature.txt"
+    Then the output should contain "feature content"

data/features/run.feature

@@ -0,0 +1,14 @@
+@server
+Feature: bard run
+  Execute commands on a remote server.
+
+  Background:
+    Given a test server is running
+
+  Scenario: executes a command on the remote server
+    When I run: bard run "echo hello"
+    Then the output should contain "hello"
+
+  Scenario: operates in the configured path
+    When I run: bard run "pwd"
+    Then the output should contain "testproject"

data/features/step_definitions/bard_steps.rb

@@ -0,0 +1,136 @@
+Given /^a test server is running$/ do
+  raise "Test server failed to start" unless @container && @ssh_port
+end
+
+When /^I run: bard (.+)$/ do |command|
+  run_bard(command)
+  unless @status.success?
+    raise "Command failed with status: #{@status}\nOutput: #{@stdout}"
+  end
+end
+
+When /^I run expecting failure: bard (.+)$/ do |command|
+  run_bard(command)
+  unless !@status.success?
+    raise "Command succeeded but was expected to fail\nOutput: #{@stdout}"
+  end
+end
+
+Then /^the output should contain "([^\"]+)"$/ do |expected|
+  expect(@stdout).to include(expected)
+end
+
+Given /^I create a file "([^\"]+)" with content "([^\"]+)"$/ do |filename, content|
+  Dir.chdir(@test_dir) do
+    File.write(filename, content)
+  end
+end
+
+Given /^I commit the changes with message "([^\"]+)"$/ do |message|
+  Dir.chdir(@test_dir) do
+    system("git add -A", out: File::NULL, err: File::NULL)
+    system("git commit -m '#{message}'", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^a file "([^\"]+)" should exist locally$/ do |filename|
+  path = File.join(@test_dir, filename)
+  expect(File.exist?(path)).to be(true), "Expected file #{filename} to exist at #{path}"
+end
+
+# Branch management
+Given /^I create and switch to branch "([^"]+)"$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git checkout -b #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^I should be on branch "([^"]+)"$/ do |expected_branch|
+  Dir.chdir(@test_dir) do
+    current = `git rev-parse --abbrev-ref HEAD`.chomp
+    expect(current).to eq(expected_branch)
+  end
+end
+
+Given /^I push branch "([^"]+)" to origin$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git push -u origin #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^branch "([^"]+)" should not exist locally$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    result = system("git rev-parse --verify #{branch_name}", out: File::NULL, err: File::NULL)
+    expect(result).to be(false), "Expected branch #{branch_name} to not exist locally"
+  end
+end
+
+Then /^branch "([^"]+)" should not exist on origin$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git fetch --prune origin", out: File::NULL, err: File::NULL)
+    result = system("git rev-parse --verify origin/#{branch_name}", out: File::NULL, err: File::NULL)
+    expect(result).to be(false), "Expected branch #{branch_name} to not exist on origin"
+  end
+end
+
+# Simulating remote changes
+Given /^master has an additional commit from another source$/ do
+  run_ssh "cd ~/testproject && git pull origin master"
+  run_ssh "cd ~/testproject && echo 'remote change' > remote-change.txt"
+  run_ssh "cd ~/testproject && git add remote-change.txt"
+  run_ssh "cd ~/testproject && git commit -m 'Remote commit on master'"
+  run_ssh "cd ~/testproject && git push origin master"
+
+  Dir.chdir(@test_dir) do
+    system("git fetch origin", out: File::NULL, err: File::NULL)
+  end
+end
+
+Given /^master has a conflicting commit to "([^"]+)"$/ do |filename|
+  run_ssh "cd ~/testproject && git pull origin master"
+  run_ssh "cd ~/testproject && echo 'conflicting content from remote' > #{filename}"
+  run_ssh "cd ~/testproject && git add #{filename}"
+  run_ssh "cd ~/testproject && git commit -m 'Remote conflicting commit'"
+  run_ssh "cd ~/testproject && git push origin master"
+
+  Dir.chdir(@test_dir) do
+    system("git fetch origin", out: File::NULL, err: File::NULL)
+  end
+end
+
+# CI setup
+Given /^a local CI script that passes$/ do
+  Dir.chdir(@test_dir) do
+    File.write("bin/rake", <<~'SCRIPT')
+#!/bin/bash
+case "$1" in
+  ci) echo "All tests passed!"; exit 0 ;;
+esac
+    SCRIPT
+    FileUtils.chmod(0o755, "bin/rake")
+  end
+end
+
+Given /^a local CI script that fails with "([^"]+)"$/ do |error_message|
+  Dir.chdir(@test_dir) do
+    File.write("bin/rake", <<~SCRIPT)
+#!/bin/bash
+case "$1" in
+  ci) echo "#{error_message}"; exit 1 ;;
+esac
+    SCRIPT
+    FileUtils.chmod(0o755, "bin/rake")
+  end
+end
+
+Given /^I switch to branch "([^"]+)"$/ do |branch_name|
+  Dir.chdir(@test_dir) do
+    system("git checkout #{branch_name}", out: File::NULL, err: File::NULL)
+  end
+end
+
+# Output negation
+Then /^the output should not contain "([^"]+)"$/ do |unexpected|
+  expect(@stdout).not_to include(unexpected)
+end
+