bard 2.0.0.beta → 2.0.1

data/lib/bard/target.rb

@@ -1,22 +1,14 @@
-require "uri"
 require "bard/command"
-require "bard/copy"
-require "bard/deploy_strategy"
 
 module Bard
   class Target
-    attr_reader :key, :config, :path
-    attr_accessor :server, :gateway, :ssh_key, :env
+    attr_reader :key, :config
 
     def initialize(key, config)
       @key = key
       @config = config
       @capabilities = []
-      @ping_urls = []
-      @strategy_options_hash = {}
-      @deploy_strategy = nil
       @path = nil
-      @server = nil
     end
 
     # Capability tracking
@@ -30,193 +22,25 @@ module Bard
 
     def require_capability!(capability)
       unless has_capability?(capability)
-        error_message = case capability
-        when :ssh
-          "SSH not configured for this target"
-        when :ping
-          "Ping URL not configured for this target"
-        else
-          "#{capability} capability not configured for this target"
-        end
-        raise error_message
-      end
-    end
-
-    # SSH configuration
-    def ssh(uri_or_false = nil, **options)
-      if uri_or_false.nil?
-        # Getter - return false if explicitly disabled, otherwise return server
-        return @ssh_disabled ? false : @server
-      elsif uri_or_false == false
-        # Disable SSH
-        @server = nil
-        @ssh_disabled = true
-        @capabilities.delete(:ssh)
-      else
-        # Enable SSH
-        require "bard/ssh_server"
-        @server = SSHServer.new(uri_or_false, **options)
-        @path = options[:path] if options[:path]
-        @gateway = options[:gateway] if options[:gateway]
-        @ssh_key = options[:ssh_key] if options[:ssh_key]
-        @env = options[:env] if options[:env]
-        enable_capability(:ssh)
-
-        # Set SSH as default deployment strategy if none set
-        @deploy_strategy ||= :ssh
-
-        # Auto-configure ping from hostname
-        hostname = @server.hostname
-        ping(hostname) if hostname
-      end
-    end
-
-    def ssh_uri
-      server&.ssh_uri
-    end
-
-    # Path configuration
-    def path(new_path = nil)
-      if new_path
-        @path = new_path
-      else
-        @path || config.project_name
-      end
-    end
-
-    # Ping configuration
-    def ping(*urls)
-      if urls.empty?
-        # Getter
-        @ping_urls
-      elsif urls.first == false
-        # Disable ping
-        @ping_urls = []
-        @capabilities.delete(:ping)
-      else
-        # Enable ping
-        @ping_urls = urls.flatten
-        enable_capability(:ping)
-      end
-    end
-
-    def ping_urls
-      @ping_urls
-    end
-
-    def ping!
-      require_capability!(:ping)
-      require "bard/ping"
-      failed_urls = Bard::Ping.call(self)
-      if failed_urls.any?
-        raise "Ping failed for: #{failed_urls.join(', ')}"
-      end
-    end
-
-    def open
-      require_capability!(:ping)
-      system "open #{ping_urls.first}"
-    end
-
-    # Deploy strategy
-    attr_reader :deploy_strategy
-
-    # GitHub Pages deployment configuration
-    def github_pages(url = nil)
-      if url.nil?
-        # Getter
-        @github_pages_url
-      else
-        # Setter
-        @deploy_strategy = :github_pages
-        @github_pages_url = url
-        enable_capability(:github_pages)
-      end
-    end
-
-    def strategy_options(strategy_name)
-      @strategy_options_hash[strategy_name] || {}
-    end
-
-    def deploy_strategy_instance
-      raise "No deployment strategy configured for target #{key}" unless @deploy_strategy
-
-      strategy_class = DeployStrategy[@deploy_strategy]
-      raise "Unknown deployment strategy: #{@deploy_strategy}" unless strategy_class
-
-      strategy_class.new(self)
-    end
-
-    # Dynamic strategy DSL via method_missing
-    def method_missing(method, *args, **kwargs, &block)
-      strategy_class = DeployStrategy[method]
-
-      if strategy_class
-        # This is a deployment strategy
-        @deploy_strategy = method
-
-        # Store options
-        @strategy_options_hash[method] = kwargs
-
-        # Auto-configure ping if first arg is a URL
-        if args.first && args.first.to_s =~ /^https?:\/\//
-          ping(args.first)
-        end
-
-        # Call the strategy's initializer if it wants to configure the target
-        # (This will be handled by the strategy class)
-      else
-        super
+        raise "#{capability} capability not configured for this target"
       end
     end
 
-    def respond_to_missing?(method, include_private = false)
-      DeployStrategy[method] || super
+    def path
+      @path || config.project_name
     end
 
-    # Remote command execution
-    def run!(command, home: false, verbose: false, quiet: false)
-      require_capability!(:ssh)
-      Command.run!(command, on: server, home: home, verbose: verbose, quiet: quiet)
+    def run!(command, home: false, verbose: false, quiet: false, capture: false)
+      result = Command.run!(command, verbose:, quiet:)
+      result if capture
     end
 
     def run(command, home: false, verbose: false, quiet: false)
-      require_capability!(:ssh)
-      Command.run(command, on: server, home: home, verbose: verbose, quiet: quiet)
+      Command.run(command, verbose:, quiet:)
     end
 
     def exec!(command, home: false)
-      require_capability!(:ssh)
-      Command.exec!(command, on: server, home: home)
-    end
-
-    # File transfer
-    def copy_file(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh)
-      Copy.file(path, from: self, to: to, verbose: verbose)
-    end
-
-    def copy_dir(path, to:, verbose: false)
-      require_capability!(:ssh)
-      to.require_capability!(:ssh)
-      Copy.dir(path, from: self, to: to, verbose: verbose)
-    end
-
-    # URI methods for compatibility
-    def scp_uri(file_path = nil)
-      uri = URI("scp://#{ssh_uri}")
-      uri.path = "/#{path}"
-      uri.path += "/#{file_path}" if file_path
-      uri
-    end
-
-    def rsync_uri(file_path = nil)
-      uri = URI("ssh://#{ssh_uri}")
-      str = "#{uri.user}@#{uri.host}"
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
+      Command.exec!(command)
     end
 
     # Utility methods
@@ -235,5 +59,23 @@ module Bard
         end
       end
     end
+
+    def ==(other)
+      return false unless other.is_a?(Bard::Target)
+      comparable_state == other.comparable_state
+    end
+    alias_method :eql?, :==
+
+    def hash
+      comparable_state.hash
+    end
+
+    protected
+
+    def comparable_state
+      (instance_variables - [:@key, :@config]).sort.map do |ivar|
+        [ivar, instance_variable_get(ivar)]
+      end
+    end
   end
 end

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "2.0.0.beta"
+  VERSION = "2.0.1"
 end
 

data/lib/bard.rb

@@ -1,3 +1 @@
-module Bard
-end
-
+require "bard/cli"

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