bard 2.0.0.beta → 2.0.0

data/spec/acceptance/docker/Dockerfile

@@ -1,12 +1,13 @@
-FROM ubuntu:22.04
+FROM ubuntu:24.04
 
 # Prevent interactive prompts
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Install SSH server and basic tools
+# Install SSH server, git, and basic tools
 RUN apt-get update && \
     apt-get install -y \
     openssh-server \
+    git \
     sudo \
     && rm -rf /var/lib/apt/lists/*
 

data/spec/bard/capability_spec.rb

@@ -1,5 +1,7 @@
 require "spec_helper"
 require "bard/target"
+require "bard/plugins/ssh/target_methods"
+require "bard/plugins/ping/target_methods"
 
 describe "Capability System" do
   let(:config) { double("config", project_name: "testapp") }
@@ -13,9 +15,9 @@ describe "Capability System" do
 
     it "can enable multiple capabilities" do
       target.enable_capability(:ssh)
-      target.enable_capability(:ping)
+      target.enable_capability(:url)
       expect(target.has_capability?(:ssh)).to be true
-      expect(target.has_capability?(:ping)).to be true
+      expect(target.has_capability?(:url)).to be true
     end
   end
 
@@ -38,59 +40,15 @@ describe "Capability System" do
 
     it "raises an error if capability is not enabled" do
       expect { target.require_capability!(:ssh) }
-        .to raise_error(/SSH not configured for this target/)
-    end
-
-    it "provides custom error message for ping capability" do
-      expect { target.require_capability!(:ping) }
-        .to raise_error(/Ping URL not configured for this target/)
-    end
-
-    it "provides generic error message for unknown capabilities" do
-      expect { target.require_capability!(:unknown) }
-        .to raise_error(/unknown capability not configured for this target/)
+        .to raise_error(/ssh capability not configured for this target/)
     end
   end
 
   describe "capability dependency checking" do
-    context "SSH-dependent methods" do
-      it "run! requires SSH capability" do
-        expect { target.run!("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "run requires SSH capability" do
-        expect { target.run("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "exec! requires SSH capability" do
-        expect { target.exec!("ls") }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "copy_file requires SSH capability" do
-        other_target = Bard::Target.new(:staging, config)
-        expect { target.copy_file("test.txt", to: other_target) }
-          .to raise_error(/SSH not configured/)
-      end
-
-      it "copy_dir requires SSH capability" do
-        other_target = Bard::Target.new(:staging, config)
-        expect { target.copy_dir("test/", to: other_target) }
-          .to raise_error(/SSH not configured/)
-      end
-    end
-
-    context "Ping-dependent methods" do
-      it "ping! requires ping capability" do
+    context "URL-dependent methods" do
+      it "ping! requires url capability" do
         expect { target.ping! }
-          .to raise_error(/Ping URL not configured/)
-      end
-
-      it "open requires ping capability" do
-        expect { target.open }
-          .to raise_error(/Ping URL not configured/)
+          .to raise_error(/url capability not configured/)
       end
     end
   end

data/spec/bard/ci/github_actions_spec.rb

@@ -1,35 +1,138 @@
-require "bard/ci/github_actions"
+require "spec_helper"
+require "bard/plugins/deploy/ci/github_actions"
 
-describe Bard::CI::GithubActions do
-  subject { described_class.new("metrc", "master", "0966308e204b256fdcc11457eb53306d84884c60") }
+BASE_URL = "https://api.github.com/repos/botandrosedesign/metrc"
+
+RSpec.shared_context "github actions stubs" do
+  let(:run_id) { 123 }
+  let(:job_id) { 456 }
+  let(:started_at) { "2024-01-15T10:00:00Z" }
+  let(:completed_at) { "2024-01-15T10:01:30Z" }
+  let(:sha) { "abc123" }
+
+  let(:run_json) do
+    {
+      "id" => run_id,
+      "status" => "completed",
+      "conclusion" => "success",
+      "head_branch" => "master",
+      "head_sha" => sha,
+      "run_started_at" => started_at,
+      "updated_at" => completed_at,
+    }
+  end
 
-  xit "works" do
-    subject.run
+  let(:job_json) do
+    {
+      "id" => job_id,
+      "started_at" => started_at,
+      "completed_at" => completed_at,
+    }
+  end
+
+  before do
+    allow(Bard::Secrets).to receive(:fetch).with("github-apikey").and_return("test-key")
   end
 end
 
 describe Bard::CI::GithubActions::API do
+  include_context "github actions stubs"
+
   subject { described_class.new("metrc") }
 
   describe "#last_successful_run" do
-    xit "has #time_elapsed" do
+    before do
+      stub_request(:get, "#{BASE_URL}/actions/runs")
+        .with(query: hash_including("status" => "success"))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("workflow_runs" => [run_json]),
+        )
+
+      stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}/jobs")
+        .with(query: hash_including("filter" => "latest"))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("jobs" => [job_json]),
+        )
+    end
+
+    it "has #time_elapsed" do
       run = subject.last_successful_run
-      run.time_elapsed
+      expect(run.time_elapsed).to eq 90
     end
 
-    xit "has #console" do
-      subject.last_successful_run.console
+    it "has #console" do
+      stub_request(:get, "#{BASE_URL}/actions/jobs/#{job_id}/logs")
+        .to_return(
+          headers: { "Content-Type" => "text/plain" },
+          body: "build log output here",
+        )
+
+      expect(subject.last_successful_run.console).to eq "build log output here"
     end
   end
 
   describe "#create_run!" do
-    xit "returns a run" do
-      subject.create_run! "master"
+    it "returns a run" do
+      stub_request(:post, "#{BASE_URL}/actions/workflows/ci.yml/dispatches")
+        .to_return(status: 204, body: "")
+
+      allow(subject).to receive(:`).with("git rev-parse master").and_return("#{sha}\n")
+
+      stub_request(:get, "#{BASE_URL}/actions/runs")
+        .with(query: hash_including("head_sha" => sha))
+        .to_return(
+          headers: { "Content-Type" => "application/json" },
+          body: JSON.dump("workflow_runs" => [run_json]),
+        )
+
+      run = subject.create_run!("master")
+      expect(run).to be_a Bard::CI::GithubActions::Run
+      expect(run.id).to eq run_id
     end
   end
 end
 
-describe Bard::Github do
-  subject { described_class.new("metrc") }
-end
+describe Bard::CI::GithubActions do
+  include_context "github actions stubs"
+
+  subject { described_class.new("metrc", "master", sha) }
+
+  it "returns true on successful run" do
+    stub_request(:post, "#{BASE_URL}/actions/workflows/ci.yml/dispatches")
+      .to_return(status: 204, body: "")
+
+    allow_any_instance_of(Bard::CI::GithubActions::API)
+      .to receive(:`).with("git rev-parse master").and_return("#{sha}\n")
 
+    stub_request(:get, "#{BASE_URL}/actions/runs")
+      .with(query: hash_including("head_sha" => sha))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("workflow_runs" => [run_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs")
+      .with(query: hash_including("status" => "success"))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("workflow_runs" => [run_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}/jobs")
+      .with(query: hash_including("filter" => "latest"))
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump("jobs" => [job_json]),
+      )
+
+    stub_request(:get, "#{BASE_URL}/actions/runs/#{run_id}")
+      .to_return(
+        headers: { "Content-Type" => "application/json" },
+        body: JSON.dump(run_json),
+      )
+
+    expect(subject.run { }).to eq true
+  end
+end

data/spec/bard/ci/jenkins_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "bard/plugins/deploy/ci/jenkins"
+
+RSpec.describe Bard::CI::Jenkins do
+  let(:jenkins) { described_class.new("test-project", "master", "abc123") }
+
+  before do
+    allow(Bard::Secrets).to receive(:fetch).with("jenkins-user").and_return("micah")
+    allow(Bard::Secrets).to receive(:fetch).with("jenkins-token").and_return("fake-token")
+  end
+
+  describe "#get_last_time_elapsed" do
+    it "returns the duration in seconds from the last stable build" do
+      xml = "<build><duration>120000</duration></build>"
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/lastStableBuild/api/xml").and_return(xml)
+
+      result = jenkins.send(:get_last_time_elapsed)
+      expect(result).to eq 120
+    end
+  end
+
+  describe "#run" do
+    let(:ci_url) { "http://micah:fake-token@ci.botandrose.com/job/test-project" }
+
+    before do
+      allow(jenkins).to receive(:sleep)
+      state = instance_double(Bard::CI::State, save: nil, delete: nil)
+      allow(jenkins).to receive(:state).and_return(state)
+    end
+
+    it "waits until the build has started before polling" do
+      allow(jenkins).to receive(:`).with("curl -s -I -X POST -L '#{ci_url}/buildWithParameters?GIT_REF=master'").and_return("Location: http://ci.botandrose.com/queue/item/99/\r\n")
+      allow(jenkins).to receive(:`).with("curl -s #{ci_url}/lastStableBuild/api/xml").and_return("<build><duration>60000</duration></build>")
+      allow(jenkins).to receive(:`).with("curl -s -g '#{ci_url}/api/json?depth=1&tree=builds[queueId,number]'").and_return(
+        '{"builds":[{"queueId":1,"number":1}]}',
+        '{"builds":[{"queueId":99,"number":5}]}',
+        '{"builds":[{"queueId":99,"number":5}]}'
+      )
+      allow(jenkins).to receive(:`).with("curl -s #{ci_url}/5/api/json?tree=building,result").and_return('{"building":false,"result":"SUCCESS"}')
+
+      result = jenkins.run { |elapsed, last_time| }
+      expect(result).to eq true
+    end
+  end
+
+  describe "#started?" do
+    before do
+      jenkins.instance_variable_set(:@queueId, 99)
+    end
+
+    it "retries when builds list is empty (job just created)" do
+      allow(jenkins).to receive(:`).with(/api\/json\?depth=1/).and_return(
+        '{"builds":[]}',
+        '{"builds":[{"queueId":99,"number":1}]}'
+      )
+      allow(jenkins).to receive(:sleep)
+
+      expect(jenkins.send(:started?)).to eq true
+    end
+  end
+
+  describe "#exists?" do
+    it "returns truthy when the job exists" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 200 OK\r\n")
+
+      expect(jenkins.exists?).to be_truthy
+    end
+
+    it "auto-creates the job when it does not exist" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 404 Not Found\r\n")
+      allow(jenkins).to receive(:`).with("git remote get-url origin").and_return("git@gitlab.com:botandrose/test-project.git\n")
+      allow(File).to receive(:exist?).with("config/master.key").and_return(false)
+      expect(jenkins).to receive(:`).with(/curl -s -X POST.*createItem\?name=test-project.*Content-Type: application\/xml/)
+
+      jenkins.exists?
+    end
+
+    it "includes a master key build step when config/master.key exists" do
+      allow(jenkins).to receive(:`).with(/curl -s -I/).and_return("HTTP/1.1 404 Not Found\r\n")
+      allow(jenkins).to receive(:`).with("git remote get-url origin").and_return("git@gitlab.com:botandrose/test-project.git\n")
+      allow(File).to receive(:exist?).with("config/master.key").and_return(true)
+      allow(File).to receive(:read).with("config/master.key").and_return("abc123secret")
+
+      config_xml = nil
+      allow(jenkins).to receive(:`).with(/createItem/) do |cmd|
+        config_xml = cmd
+        ""
+      end
+
+      jenkins.exists?
+      expect(config_xml).to include("abc123secret")
+      expect(config_xml).to include("config/master.key")
+    end
+  end
+
+  describe "#building? and #success?" do
+    before do
+      jenkins.instance_variable_set(:@job_id, 42)
+    end
+
+    it "detects a successful build" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":false,"result":"SUCCESS"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq true
+    end
+
+    it "detects a failed build" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":false,"result":"FAILURE"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq false
+    end
+
+    it "detects a build in progress" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"building":true,"result":null}')
+
+      expect(jenkins.send(:building?)).to eq true
+    end
+
+    it "handles JSON with spaces in keys" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return('{"_class":"hudson.model.FreeStyleBuild","building":false,"result":"SUCCESS"}')
+
+      expect(jenkins.send(:building?)).to eq false
+      expect(jenkins.send(:success?)).to eq true
+    end
+
+    it "success? reflects the last response from building?" do
+      allow(jenkins).to receive(:`).with("curl -s http://micah:fake-token@ci.botandrose.com/job/test-project/42/api/json?tree=building,result").and_return(
+        '{"building":true,"result":null}',
+        '{"building":false,"result":"SUCCESS"}'
+      )
+
+      jenkins.send(:building?) # first call — still building
+      jenkins.send(:building?) # second call — done
+      expect(jenkins.send(:success?)).to eq true
+    end
+  end
+end

data/spec/bard/ci/runner_spec.rb

@@ -0,0 +1,61 @@
+require "bard/plugins/deploy/ci/runner"
+
+RSpec.describe Bard::CI::Runner do
+  describe ".runners" do
+    it "is a hash registry" do
+      expect(described_class.runners).to be_a(Hash)
+    end
+  end
+
+  describe ".[]" do
+    before do
+      require "bard/plugins/deploy/ci/local"
+      require "bard/plugins/deploy/ci/github_actions"
+    end
+
+    it "looks up runners by name" do
+      expect(described_class[:local]).to eq Bard::CI::Local
+      expect(described_class[:github_actions]).to eq Bard::CI::GithubActions
+    end
+
+    it "returns nil for unknown runners" do
+      expect(described_class[:nonexistent]).to be_nil
+    end
+  end
+
+  describe ".default" do
+    it "returns the last registered runner" do
+      # Whatever was registered last in the current test run
+      expect(described_class.default).to be_a(Class)
+      expect(described_class.default.ancestors).to include(Bard::CI::Runner)
+    end
+  end
+
+  describe "auto-registration via inherited" do
+    it "registers subclasses automatically" do
+      eval <<-RUBY
+        module Bard
+          class CI
+            class SpecTestRunner < Runner
+            end
+          end
+        end
+      RUBY
+
+      expect(described_class[:spec_test_runner]).to eq Bard::CI::SpecTestRunner
+    end
+
+    it "newly registered runner becomes the default" do
+      eval <<-RUBY
+        module Bard
+          class CI
+            class AnotherTestRunner < Runner
+            end
+          end
+        end
+      RUBY
+
+      expect(described_class.default).to eq Bard::CI::AnotherTestRunner
+    end
+  end
+end

data/spec/bard/ci_spec.rb

@@ -1,4 +1,4 @@
-require "bard/ci"
+require "bard/plugins/deploy/ci"
 
 describe Bard::CI do
   subject { described_class.new("tracker", "master") }

data/spec/bard/cli/ci_spec.rb

@@ -1,28 +1,14 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/ci"
-require "thor"
+require "ostruct"
 
-class TestCICLI < Thor
-  include Bard::CLI::CI
-
-  attr_reader :options
-
-  def initialize
-    super
-    @options = {}
-  end
-
-  def project_name
-    "test_project"
-  end
-end
-
-describe Bard::CLI::CI do
-  let(:cli) { TestCICLI.new }
+describe "bard ci" do
+  let(:cli) { Bard::CLI.new }
   let(:ci_runner) { double("ci_runner") }
 
   before do
+    allow(cli).to receive(:config).and_return(OpenStruct.new(ci: nil))
+    allow(cli).to receive(:project_name).and_return("test_project")
     allow(cli).to receive(:puts)
     allow(cli).to receive(:print)
     allow(cli).to receive(:exit)
@@ -101,12 +87,9 @@ describe Bard::CLI::CI do
       it "shows error message and exits" do
         allow(cli).to receive(:options).and_return({})
         allow(ci_runner).to receive(:exists?).and_return(false)
+        allow(cli).to receive(:exit).with(1).and_raise(SystemExit)
 
-        expect(cli).to receive(:puts) # "No CI found for test_project!"
-        expect(cli).to receive(:puts) # "Re-run with --skip-ci to bypass CI..."
-        expect(cli).to receive(:exit).with(1)
-
-        cli.ci
+        expect { cli.ci }.to raise_error(SystemExit)
       end
     end
 
@@ -116,7 +99,7 @@ describe Bard::CLI::CI do
         allow(ci_runner).to receive(:exists?).and_return(true)
         allow(ci_runner).to receive(:run).and_return(true)
 
-        expect(Bard::CI).to receive(:new).with("test_project", "develop", local: nil)
+        expect(Bard::CI).to receive(:new).with("test_project", "develop", runner_name: nil)
         expect(cli).to receive(:puts).with("Continuous integration: starting build on develop...")
 
         cli.ci("develop")
@@ -124,12 +107,36 @@ describe Bard::CLI::CI do
     end
 
     context "with local-ci option" do
-      it "passes local option to CI runner" do
+      it "passes local runner_name to CI" do
         allow(cli).to receive(:options).and_return({ "local-ci" => true })
         allow(ci_runner).to receive(:exists?).and_return(true)
         allow(ci_runner).to receive(:run).and_return(true)
 
-        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", local: true)
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :local)
+
+        cli.ci
+      end
+    end
+
+    context "with ci option" do
+      it "passes specified runner_name to CI" do
+        allow(cli).to receive(:options).and_return({ "ci" => "jenkins" })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :jenkins)
+
+        cli.ci
+      end
+    end
+
+    context "with both local-ci and ci options" do
+      it "local-ci takes precedence" do
+        allow(cli).to receive(:options).and_return({ "local-ci" => true, "ci" => "jenkins" })
+        allow(ci_runner).to receive(:exists?).and_return(true)
+        allow(ci_runner).to receive(:run).and_return(true)
+
+        expect(Bard::CI).to receive(:new).with("test_project", "feature-branch", runner_name: :local)
 
         cli.ci
       end

data/spec/bard/cli/data_spec.rb

@@ -1,35 +1,15 @@
 require "spec_helper"
 require "bard/cli"
-require "bard/cli/data"
 
-require "thor"
-
-require "term/ansicolor"
-
-class TestCLI < Thor
-  include Bard::CLI::Data
-  include Term::ANSIColor
-
-  attr_reader :config
-
-  def initialize
-    @config = {}
-  end
-
-  def options
-    {}
-  end
-end
-
-describe Bard::CLI::Data do
-  let(:cli) { TestCLI.new }
+describe "bard data" do
+  let(:cli) { Bard::CLI.new }
 
   it "should have a data command" do
     expect(cli).to respond_to(:data)
   end
 
   context "data" do
-    let(:from) { double("from", key: :production, run!: nil, copy_file: nil, copy_dir: nil) }
+    let(:from) { double("from", key: :production, run!: nil, require_capability!: nil) }
     let(:to) { double("to", key: :local, run!: nil) }
 
     let(:config) do
@@ -42,17 +22,18 @@ describe Bard::CLI::Data do
     before do
       allow(cli).to receive(:config).and_return(config)
       allow(cli).to receive(:options).and_return({from: "production", to: "local"})
+      allow(cli).to receive(:puts)
     end
 
     it "should run the data command" do
       expect(from).to receive(:run!).with("bin/rake db:dump")
-      expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+      expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
       expect(to).to receive(:run!).with("bin/rake db:load")
       cli.data
     end
 
     context "pushing to production" do
-      let(:to) { double("to", key: :production, ping: ["https://example.com"]) }
+      let(:to) { double("to", key: :production, url: "https://example.com", run!: nil, require_capability!: nil) }
 
       before do
         allow(cli).to receive(:options).and_return({from: "local", to: "production"})
@@ -68,7 +49,7 @@ describe Bard::CLI::Data do
       it "should allow pushing to production if the user confirms" do
         expect(cli).to receive(:ask).and_return("https://example.com")
         expect(from).to receive(:run!).with("bin/rake db:dump")
-        expect(from).to receive(:copy_file).with("db/data.sql.gz", to: to, verbose: true)
+        expect(Bard::Copy).to receive(:file).with("db/data.sql.gz", from: from, to: to, verbose: true)
         expect(to).to receive(:run!).with("bin/rake db:load")
         cli.data
       end