bard 1.8.0 → 1.9.1

data/spec/bard/ci/jenkins_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+require "bard/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/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/ci/local"
+      require "bard/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/cli/ci_spec.rb

@@ -2,6 +2,7 @@ require "spec_helper"
 require "bard/cli"
 require "bard/cli/ci"
 require "thor"
+require "ostruct"
 
 class TestCICLI < Thor
   include Bard::CLI::CI
@@ -16,6 +17,10 @@ class TestCICLI < Thor
   def project_name
     "test_project"
   end
+
+  def config
+    @config ||= OpenStruct.new(ci: nil)
+  end
 end
 
 describe Bard::CLI::CI do
@@ -101,12 +106,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 +118,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 +126,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/deploy_spec.rb

@@ -26,6 +26,7 @@ describe Bard::CLI::Deploy do
 
   before do
     allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:options).and_return({ target: "production" })
     allow(cli).to receive(:puts)
     allow(cli).to receive(:exit)
     allow(cli).to receive(:run!)
@@ -48,7 +49,7 @@ describe Bard::CLI::Deploy do
     context "when on master branch" do
       before do
         allow(Bard::Git).to receive(:current_branch).and_return("master")
-        allow(cli).to receive(:options).and_return({})
+        allow(cli).to receive(:options).and_return({ target: "production" })
       end
 
       context "when up to date with remote" do
@@ -79,7 +80,7 @@ describe Bard::CLI::Deploy do
 
       context "with skip-ci option" do
         it "skips CI step" do
-          allow(cli).to receive(:options).and_return({ "skip-ci" => true })
+          allow(cli).to receive(:options).and_return({ "skip-ci" => true, target: "production" })
 
           expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
           expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
@@ -91,16 +92,16 @@ describe Bard::CLI::Deploy do
 
     context "when on feature branch" do
       before do
-        allow(cli).to receive(:options).and_return({})
+        allow(cli).to receive(:options).and_return({ target: "production" })
       end
 
       context "with fast-forward merge possible" do
         it "fetches master, pushes branch, runs CI, merges to master, and deploys" do
-          expect(cli).to receive(:run!).with("git fetch origin master:master")
+          expect(cli).to receive(:run!).with("git fetch origin")
+          expect(cli).to receive(:run!).with("git fetch origin master:master").twice
           expect(cli).to receive(:run!).with("git push -f origin feature-branch:feature-branch")
           expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], {})
           expect(cli).to receive(:run!).with("git push origin feature-branch:master")
-          expect(cli).to receive(:run!).with("git fetch origin master:master")
           expect(production_server).to receive(:run!).with("git pull origin master && bin/setup")
 
           cli.deploy
@@ -141,7 +142,7 @@ describe Bard::CLI::Deploy do
 
     context "with clone option" do
       it "clones repository and sets up application" do
-        allow(cli).to receive(:options).and_return({ clone: true })
+        allow(cli).to receive(:options).and_return({ clone: true, target: "production" })
 
         expect(production_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project /var/www/test_project", home: true)
         expect(cli).to receive(:invoke).with(:master_key, [], from: "local", to: :production)
@@ -168,13 +169,14 @@ describe Bard::CLI::Deploy do
 
       before do
         allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+        allow(cli).to receive(:options).and_return({ target: "staging" })
       end
 
       it "deploys to specified target" do
         expect(staging_server).to receive(:run!).with("git pull origin master && bin/setup")
         expect(cli).to receive(:ping).with(:staging)
 
-        cli.deploy(:staging)
+        cli.deploy
       end
     end
 
@@ -191,12 +193,22 @@ describe Bard::CLI::Deploy do
 
     context "with local-ci option" do
       it "passes local-ci option to CI invocation" do
-        allow(cli).to receive(:options).and_return({ "local-ci" => true })
+        allow(cli).to receive(:options).and_return({ "local-ci" => true, target: "production" })
 
         expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], { "local-ci" => true })
 
         cli.deploy
       end
     end
+
+    context "with ci option" do
+      it "passes ci option to CI invocation" do
+        allow(cli).to receive(:options).and_return({ "ci" => "jenkins", target: "production" })
+
+        expect(cli).to receive(:invoke).with(:ci, ["feature-branch"], { "ci" => "jenkins" })
+
+        cli.deploy
+      end
+    end
   end
 end

data/spec/bard/cli/hurt_spec.rb

@@ -4,7 +4,7 @@ require "bard/cli/hurt"
 require "thor"
 
 class TestHurtCLI < Thor
-  include Bard::CLI::Hurt
+  Bard::CLI::Hurt.setup(self)
 end
 
 describe Bard::CLI::Hurt do
@@ -20,4 +20,4 @@ describe Bard::CLI::Hurt do
       expect(cli).to respond_to(:hurt)
     end
   end
-end
+end

data/spec/bard/cli/install_spec.rb

@@ -4,7 +4,7 @@ require "bard/cli/install"
 require "thor"
 
 class TestInstallCLI < Thor
-  include Bard::CLI::Install
+  Bard::CLI::Install.setup(self)
 end
 
 describe Bard::CLI::Install do
@@ -16,10 +16,10 @@ describe Bard::CLI::Install do
     end
 
     it "should copy install files to bin directory" do
-      expect(cli).to receive(:system).with(/cp -R .*install_files\/\* bin\//)
-      expect(cli).to receive(:system).with(/cp -R .*install_files\/\.github \.\//)
+      expect_any_instance_of(Bard::CLI::Install).to receive(:system).with(/cp -R .*install_files\/\* bin\//)
+      expect_any_instance_of(Bard::CLI::Install).to receive(:system).with(/cp -R .*install_files\/\.github \.\//)
 
       cli.install
     end
   end
-end
+end

data/spec/bard/cli/open_spec.rb

@@ -4,7 +4,7 @@ require "bard/cli/open"
 require "thor"
 
 class TestOpenCLI < Thor
-  include Bard::CLI::Open
+  Bard::CLI::Open.setup(self)
 
   attr_reader :config
 
@@ -25,7 +25,7 @@ describe Bard::CLI::Open do
 
   before do
     allow(cli).to receive(:config).and_return(config)
-    allow(cli).to receive(:exec)
+    allow_any_instance_of(Bard::CLI::Open).to receive(:exec)
   end
 
   describe "#open" do
@@ -34,7 +34,7 @@ describe Bard::CLI::Open do
     end
 
     it "should open production server URL by default" do
-      expect(cli).to receive(:exec).with("xdg-open https://example.com")
+      expect_any_instance_of(Bard::CLI::Open).to receive(:exec).with("xdg-open https://example.com")
 
       cli.open
     end
@@ -43,13 +43,13 @@ describe Bard::CLI::Open do
       staging_server = double("staging", ping: ["https://staging.example.com"])
       allow(config).to receive(:[]).with(:staging).and_return(staging_server)
 
-      expect(cli).to receive(:exec).with("xdg-open https://staging.example.com")
+      expect_any_instance_of(Bard::CLI::Open).to receive(:exec).with("xdg-open https://staging.example.com")
 
       cli.open(:staging)
     end
 
     it "should open CI URL when server is ci" do
-      expect(cli).to receive(:exec).with("xdg-open https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
+      expect_any_instance_of(Bard::CLI::Open).to receive(:exec).with("xdg-open https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
 
       cli.open(:ci)
     end
@@ -57,11 +57,13 @@ describe Bard::CLI::Open do
 
   describe "#open_url" do
     it "returns CI URL for ci server" do
-      expect(cli.send(:open_url, :ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
+      command = Bard::CLI::Open.new(cli)
+      expect(command.send(:open_url, :ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
     end
 
     it "returns server ping URL for other servers" do
-      expect(cli.send(:open_url, :production)).to eq("https://example.com")
+      command = Bard::CLI::Open.new(cli)
+      expect(command.send(:open_url, :production)).to eq("https://example.com")
     end
   end
-end
+end

data/spec/bard/cli/ping_spec.rb

@@ -4,7 +4,7 @@ require "bard/cli/ping"
 require "thor"
 
 class TestPingCLI < Thor
-  include Bard::CLI::Ping
+  Bard::CLI::Ping.setup(self)
 
   attr_reader :config
 
@@ -21,8 +21,8 @@ describe Bard::CLI::Ping do
 
   before do
     allow(cli).to receive(:config).and_return(config)
-    allow(cli).to receive(:puts)
-    allow(cli).to receive(:exit)
+    allow_any_instance_of(Bard::CLI::Ping).to receive(:puts)
+    allow_any_instance_of(Bard::CLI::Ping).to receive(:exit)
   end
 
   describe "#ping" do
@@ -39,9 +39,9 @@ describe Bard::CLI::Ping do
     it "should print down URLs when they exist" do
       down_urls = ["https://down.example.com"]
       allow(Bard::Ping).to receive(:call).and_return(down_urls)
-      expect(cli).to receive(:puts).with("https://down.example.com is down!")
+      expect_any_instance_of(Bard::CLI::Ping).to receive(:puts).with("https://down.example.com is down!")
 
       cli.ping
     end
   end
-end
+end

data/spec/bard/cli/run_spec.rb

@@ -25,6 +25,7 @@ describe Bard::CLI::Run do
     allow(cli).to receive(:exit)
     allow(cli).to receive(:red).and_return("")
     allow(cli).to receive(:yellow).and_return("")
+    allow(cli).to receive(:options).and_return({ target: "production" })
   end
 
   describe "#run" do
@@ -33,7 +34,25 @@ describe Bard::CLI::Run do
     end
 
     it "should run command on production server" do
-      expect(server).to receive(:run!).with("ls -la", verbose: true)
+      expect(server).to receive(:run!).with("ls -la", verbose: true, home: nil)
+
+      cli.run("ls", "-la")
+    end
+
+    it "should run command on specified target" do
+      staging_server = double("staging_server")
+      allow(cli).to receive(:config).and_return(config.merge(staging: staging_server))
+      allow(cli).to receive(:options).and_return({ target: "staging" })
+
+      expect(staging_server).to receive(:run!).with("ls -la", verbose: true, home: nil)
+
+      cli.run("ls", "-la")
+    end
+
+    it "should pass home option to target" do
+      allow(cli).to receive(:options).and_return({ target: "production", home: true })
+
+      expect(server).to receive(:run!).with("ls -la", verbose: true, home: true)
 
       cli.run("ls", "-la")
     end

data/spec/bard/cli/stage_spec.rb

@@ -55,6 +55,26 @@ describe Bard::CLI::Stage do
       end
     end
 
+    context "when staging target has a deploy strategy" do
+      let(:strategy_instance) { double("strategy") }
+      let(:staging_server) { double("staging", deploy_strategy: :fake) }
+
+      before do
+        allow(staging_server).to receive(:respond_to?).with(:deploy_strategy).and_return(true)
+        allow(staging_server).to receive(:deploy_strategy_instance).and_return(strategy_instance)
+        allow(cli).to receive(:require).with("bard/deploy_strategy/fake").and_return(true)
+      end
+
+      it "uses the deploy strategy instead of SSH" do
+        expect(cli).to receive(:run!).with("git push -u origin main", verbose: true)
+        expect(strategy_instance).to receive(:deploy)
+        expect(staging_server).not_to receive(:run!)
+        expect(cli).to receive(:ping).with(:staging)
+
+        cli.stage
+      end
+    end
+
     context "when production server is not defined" do
       let(:servers) { { staging: staging_server } }
 

data/spec/bard/cli/vim_spec.rb

@@ -4,14 +4,14 @@ require "bard/cli/vim"
 require "thor"
 
 class TestVimCLI < Thor
-  include Bard::CLI::Vim
+  Bard::CLI::Vim.setup(self)
 end
 
 describe Bard::CLI::Vim do
   let(:cli) { TestVimCLI.new }
 
   before do
-    allow(cli).to receive(:exec)
+    allow_any_instance_of(Bard::CLI::Vim).to receive(:exec)
   end
 
   describe "#vim" do
@@ -20,15 +20,15 @@ describe Bard::CLI::Vim do
     end
 
     it "should exec vim with git diff files by default" do
-      expect(cli).to receive(:exec).with("vim -p `(git diff master --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
+      expect_any_instance_of(Bard::CLI::Vim).to receive(:exec).with("vim -p `(git diff master --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
 
       cli.vim
     end
 
     it "should exec vim with specified branch" do
-      expect(cli).to receive(:exec).with("vim -p `(git diff develop --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
+      expect_any_instance_of(Bard::CLI::Vim).to receive(:exec).with("vim -p `(git diff develop --name-only; git ls-files --others --exclude-standard) | grep -v '^app/assets/images/' | grep -v '^app/assets/stylesheets/' | while read f; do [ -f \"$f\" ] && ! file -b \"$f\" | grep -q \"binary\" && echo \"$f\"; done | tac`")
 
       cli.vim("develop")
     end
   end
-end
+end

data/spec/bard/config_spec.rb

@@ -148,6 +148,18 @@ describe Bard::Config do
     end
   end
 
+  context "with target overriding default server" do
+    subject { described_class.new("tracker", source: <<~SOURCE) }
+      target :staging do
+        ssh false
+      end
+    SOURCE
+
+    it "replaces the default Server with a Target" do
+      expect(subject[:staging]).to be_a(Bard::Target)
+    end
+  end
+
   context "with github_pages directive" do
     subject { described_class.new("test", source: "github_pages 'example.com'") }
 

data/spec/bard/github_spec.rb

@@ -5,7 +5,7 @@ describe Bard::Github do
   let(:github) { Bard::Github.new("test-project") }
 
   before do
-    allow(github).to receive(:`).with("git ls-remote -t git@github.com:botandrosedesign/secrets").and_return("github-apikey|12345")
+    allow(Bard::Secrets).to receive(:fetch).with("github-apikey").and_return("12345")
   end
 
   describe "#get" do