bard 2.2.0 → 3.0.0

data/spec/bard/cli/deploy_spec.rb

@@ -1,243 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard deploy" do
-  let(:deploy_strategy) { double("deploy_strategy", deploy: true) }
-  let(:production_server) { double("production", run!: true, path: "/var/www/test_project", deploy_strategy: :ssh, deploy_strategy_instance: deploy_strategy) }
-  let(:config) { { production: production_server } }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(config).to receive(:ci).and_return(nil)
-    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!)
-    allow(cli).to receive(:invoke)
-    allow(cli).to receive(:ping)
-    allow(cli).to receive(:project_name).and_return("test_project")
-    allow(cli).to receive(:green).and_return("")
-    allow(cli).to receive(:red).and_return("")
-    allow(cli).to receive(:yellow).and_return("")
-    allow(Bard::Git).to receive(:current_branch).and_return("feature-branch")
-    allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(true)
-    allow(Bard::Git).to receive(:fast_forward_merge?).and_return(true)
-    allow(Bard::Git).to receive(:in_linked_worktree?).and_return(false)
-    allow(cli).to receive(:`).and_return("")
-  end
-
-  describe "#deploy" do
-    it "should have a deploy command" do
-      expect(cli).to respond_to(:deploy)
-    end
-
-    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({ target: "production" })
-      end
-
-      context "when up to date with remote" do
-        it "skips push and runs CI then deploys" do
-          allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(true)
-
-          expect(cli).not_to receive(:run!).with(/git push/)
-          expect(cli).to receive(:invoke).with(:ci, ["master"], {})
-          expect(deploy_strategy).to receive(:deploy)
-          expect(cli).to receive(:ping).with(:production)
-
-          cli.deploy
-        end
-      end
-
-      context "when not up to date with remote" do
-        it "pushes master then runs CI and deploys" do
-          allow(Bard::Git).to receive(:up_to_date_with_remote?).and_return(false)
-
-          expect(cli).to receive(:run!).with("git push origin master:master")
-          expect(cli).to receive(:invoke).with(:ci, ["master"], {})
-          expect(deploy_strategy).to receive(:deploy)
-
-          cli.deploy
-        end
-      end
-
-      context "with skip-ci option" do
-        it "skips CI step" do
-          allow(cli).to receive(:options).and_return({ "skip-ci" => true, target: "production" })
-
-          expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
-          expect(deploy_strategy).to receive(:deploy)
-
-          cli.deploy
-        end
-      end
-
-      context "with ci disabled in config" do
-        it "skips CI step" do
-          allow(config).to receive(:ci).and_return(false)
-
-          expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
-          expect(deploy_strategy).to receive(:deploy)
-
-          cli.deploy
-        end
-      end
-    end
-
-    context "when on feature branch" do
-      before do
-        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")
-          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(deploy_strategy).to receive(:deploy)
-
-          cli.deploy
-        end
-
-        it "deletes the feature branch after successful deploy" do
-          expect(cli).to receive(:puts).with("Deleting branch: feature-branch")
-          expect(cli).to receive(:run!).with("git push --delete origin feature-branch")
-          expect(cli).to receive(:run!).with("git checkout master")
-          expect(cli).to receive(:run!).with("git branch -D feature-branch")
-
-          cli.deploy
-        end
-      end
-
-      context "when run from a linked worktree" do
-        before do
-          allow(Bard::Git).to receive(:in_linked_worktree?).and_return(true)
-          allow(cli).to receive(:`).with("git rev-parse --git-common-dir").and_return("/main/checkout/.git\n")
-          allow(Dir).to receive(:pwd).and_return("/main/checkout/tmp/worktrees/feature-branch")
-          allow(Dir).to receive(:chdir).with("/main/checkout")
-        end
-
-        it "skips writes to local master, removes the worktree, and reports where to cd back" do
-          expect(cli).not_to receive(:run!).with("git fetch origin master:master")
-          expect(cli).not_to receive(:run!).with("git checkout master")
-          expect(cli).to receive(:run!).with("git fetch origin master")
-          expect(Dir).to receive(:chdir).with("/main/checkout")
-          expect(cli).to receive(:run!).with("git worktree remove /main/checkout/tmp/worktrees/feature-branch")
-          expect(cli).to receive(:run!).with("git branch -D feature-branch")
-          expect(cli).to receive(:puts).with("Worktree removed. Run: cd /main/checkout")
-
-          cli.deploy
-        end
-      end
-
-      context "when rebase is needed" do
-        it "attempts rebase before proceeding" do
-          allow(Bard::Git).to receive(:fast_forward_merge?).and_return(false)
-
-          expect(cli).to receive(:puts).with("The master branch has advanced. Attempting rebase...")
-          expect(cli).to receive(:run!).with("git rebase origin/master")
-          expect(cli).to receive(:run!).with("git push -f origin feature-branch:feature-branch")
-
-          cli.deploy
-        end
-      end
-    end
-
-    context "when on feature branch with ci disabled in config" do
-      before do
-        allow(cli).to receive(:options).and_return({ target: "production" })
-        allow(config).to receive(:ci).and_return(false)
-      end
-
-      it "skips CI step" do
-        expect(cli).not_to receive(:invoke).with(:ci, anything, anything)
-        expect(deploy_strategy).to receive(:deploy)
-
-        cli.deploy
-      end
-    end
-
-    context "with github remote" do
-      it "pushes to github remote" do
-        allow(cli).to receive(:`).with("git remote").and_return("origin\ngithub\n")
-
-        expect(cli).to receive(:run!).with("git push github")
-
-        cli.deploy
-      end
-    end
-
-    context "with clone option" do
-      it "deploys with clone option to strategy" do
-        allow(cli).to receive(:options).and_return({ clone: true, target: "production" })
-
-        expect(deploy_strategy).to receive(:deploy).with(clone: "test_project")
-
-        cli.deploy
-      end
-    end
-
-    context "with github pages" do
-      let(:deploy_strategy) { double("github_pages_strategy") }
-      let(:production_server) { double("production", run!: true, path: "/var/www/test_project", deploy_strategy: :github_pages, deploy_strategy_instance: deploy_strategy) }
-
-      it "deploys using deploy strategy" do
-        expect(deploy_strategy).to receive(:deploy)
-
-        cli.deploy
-      end
-    end
-
-    context "with custom deployment target" do
-      let(:staging_strategy) { double("staging_strategy", deploy: true) }
-      let(:staging_server) { double("staging", run!: true, deploy_strategy: :ssh, deploy_strategy_instance: staging_strategy) }
-
-      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_strategy).to receive(:deploy)
-        expect(cli).to receive(:ping).with(:staging)
-
-        cli.deploy
-      end
-    end
-
-    context "when command fails" do
-      it "handles errors gracefully" do
-        allow(cli).to receive(:run!).and_raise(Bard::Command::Error.new("Git push failed"))
-
-        expect(cli).to receive(:puts).with(/Running command failed/)
-        expect(cli).to receive(:exit).with(1)
-
-        cli.deploy
-      end
-    end
-
-    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, 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

@@ -1,17 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard hurt" do
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:puts)
-    allow(cli).to receive(:system)
-  end
-
-  describe "#hurt" do
-    it "should have a hurt command" do
-      expect(cli).to respond_to(:hurt)
-    end
-  end
-end

data/spec/bard/cli/install_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard install" do
-  let(:cli) { Bard::CLI.new }
-
-  describe "#install" do
-    it "should have an install command" do
-      expect(cli).to respond_to(:install)
-    end
-
-    it "should copy install files to bin directory" do
-      expect(cli).to receive(:system).with(/cp -R .*plugins\/install\/\* bin\//)
-      expect(cli).to receive(:system).with(/cp -R .*plugins\/install\/\.github \.\//)
-
-      cli.install
-    end
-  end
-end

data/spec/bard/cli/master_key_spec.rb

@@ -1,38 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard master_key" do
-  let(:from_server) { double("production") }
-  let(:to_server) { double("local") }
-  let(:config) { { production: from_server, local: to_server } }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:config).and_return(config)
-  end
-
-  describe "#master_key" do
-    it "should have a master_key command" do
-      expect(cli).to respond_to(:master_key)
-    end
-
-    it "should copy master key from production to local by default" do
-      allow(config).to receive(:[]).with("production").and_return(from_server)
-      allow(config).to receive(:[]).with("local").and_return(to_server)
-      allow(cli).to receive(:options).and_return({ from: "production", to: "local" })
-      expect(Bard::Copy).to receive(:file).with("config/master.key", from: from_server, to: to_server)
-
-      cli.master_key
-    end
-
-    it "should copy master key with custom servers" do
-      staging_server = double("staging")
-      allow(config).to receive(:[]).with("production").and_return(staging_server)
-      allow(config).to receive(:[]).with("local").and_return(to_server)
-      allow(cli).to receive(:options).and_return({ from: "production", to: "local" })
-      expect(Bard::Copy).to receive(:file).with("config/master.key", from: staging_server, to: to_server)
-
-      cli.master_key
-    end
-  end
-end

data/spec/bard/cli/open_spec.rb

@@ -1,51 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard open" do
-  let(:target) { double("target", url: "https://example.com", require_capability!: nil) }
-  let(:config) { { production: target } }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:config).and_return(config)
-    allow(cli).to receive(:project_name).and_return("test_project")
-    allow(cli).to receive(:exec)
-  end
-
-  describe "#open" do
-    it "should have an open command" do
-      expect(cli).to respond_to(:open)
-    end
-
-    it "should open production target URL by default" do
-      expect(cli).to receive(:exec).with("xdg-open https://example.com")
-
-      cli.open
-    end
-
-    it "should open specified target URL" do
-      staging_server = double("staging", url: "https://staging.example.com", require_capability!: nil)
-      allow(config).to receive(:[]).with(:staging).and_return(staging_server)
-
-      expect(cli).to receive(:exec).with("xdg-open https://staging.example.com")
-
-      cli.open(:staging)
-    end
-
-    it "should open CI URL when target is ci" do
-      expect(cli).to receive(:exec).with("xdg-open https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
-
-      cli.open(:ci)
-    end
-  end
-
-  describe "#open_url" do
-    it "returns CI URL for ci target" do
-      expect(cli.open_url(:ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
-    end
-
-    it "returns target url for other targets" do
-      expect(cli.open_url(:production)).to eq("https://example.com")
-    end
-  end
-end

data/spec/bard/cli/ping_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "thor"
-
-describe "bard ping" do
-  let(:target) { double("target", ping: ["https://example.com"]) }
-  let(:config) { double("config", targets: { production: target }) }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:config).and_return(config)
-    allow(config).to receive(:[]).with(:production).and_return(target)
-    allow(cli).to receive(:puts)
-    allow(cli).to receive(:exit)
-  end
-
-  describe "#ping" do
-    it "should call Bard::Ping with the target" do
-      expect(Bard::Ping).to receive(:call).with(target).and_return([])
-
-      cli.ping
-    end
-
-    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!")
-
-      cli.ping
-    end
-  end
-end

data/spec/bard/cli/run_spec.rb

@@ -1,57 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard run" do
-  let(:target) { double("target") }
-  let(:config) { { production: target } }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:config).and_return(config)
-    allow(cli).to receive(:puts)
-    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
-    it "should have a run command" do
-      expect(cli).to respond_to(:run)
-    end
-
-    it "should run command on production target" do
-      expect(target).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_target")
-      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(target).to receive(:run!).with("ls -la", verbose: true, home: true)
-
-      cli.run("ls", "-la")
-    end
-
-    it "should handle command errors" do
-      error = Bard::Command::Error.new("Command failed")
-      allow(target).to receive(:run!).and_raise(error)
-
-      expect(cli).to receive(:puts).with(/Running command failed/)
-      expect(cli).to receive(:exit).with(1)
-
-      cli.run("failing-command")
-    end
-  end
-end

data/spec/bard/cli/setup_spec.rb

@@ -1,99 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard setup" do
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:project_name).and_return("test_project")
-    allow(Dir).to receive(:pwd).and_return("/home/user/project")
-    allow(File).to receive(:exist?).and_return(false)
-    allow(cli).to receive(:system)
-  end
-
-  describe "#setup" do
-    before { allow(cli).to receive(:nginx_server_name).and_return("test_project.localhost") }
-
-    it "should have a setup command" do
-      expect(cli).to respond_to(:setup)
-    end
-
-    context "in production" do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("production")
-      end
-
-      it "creates an nginx reverse proxy config" do
-        expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project.*proxy_pass http:\/\/puma/m)
-        expect(cli).to receive(:system).with(/sudo ln -sf/)
-        expect(cli).to receive(:system).with("sudo service nginx restart")
-
-        cli.setup
-      end
-    end
-
-    context "in staging" do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("staging")
-      end
-
-      it "creates a Passenger nginx config, not a puma reverse proxy" do
-        expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project.*include \/etc\/nginx\/snippets\/common\.conf/m)
-        expect(cli).not_to receive(:system).with(/proxy_pass http:\/\/puma/m)
-        expect(cli).to receive(:system).with(/sudo ln -sf/)
-        expect(cli).to receive(:system).with("sudo service nginx restart")
-
-        cli.setup
-      end
-    end
-
-    context "in development" do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("development")
-      end
-
-      it "creates an nginx config that includes the shared dev snippet" do
-        expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project.*include \/etc\/nginx\/snippets\/common\.conf/m)
-        expect(cli).to receive(:system).with(/sudo ln -sf/)
-        expect(cli).to receive(:system).with("sudo service nginx restart")
-
-        cli.setup
-      end
-    end
-  end
-
-  describe "#nginx_server_name" do
-    let(:production_server) { double("production", url: "https://example.com") }
-
-    before do
-      allow(cli).to receive(:config).and_return({ production: production_server })
-    end
-
-    context "when RAILS_ENV is production" do
-      before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("production") }
-
-      it "returns production server names with wildcard" do
-        expect(cli.nginx_server_name).to eq("*.example.com _")
-      end
-    end
-
-    context "when RAILS_ENV is staging" do
-      before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("staging") }
-
-      it "returns staging server name" do
-        expect(cli.nginx_server_name).to eq("test_project.botandrose.com")
-      end
-    end
-
-    context "when RAILS_ENV is development" do
-      before { allow(ENV).to receive(:[]).with("RAILS_ENV").and_return("development") }
-
-      it "returns localhost server name" do
-        expect(cli.nginx_server_name).to eq("test_project.localhost")
-      end
-    end
-  end
-end

data/spec/bard/cli/ssh_spec.rb

@@ -1,40 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-
-describe "bard ssh" do
-  let(:target) { double("target") }
-  let(:config) { { production: target } }
-  let(:cli) { Bard::CLI.new }
-
-  before do
-    allow(cli).to receive(:config).and_return(config)
-    allow(cli).to receive(:options).and_return({ home: false })
-  end
-
-  describe "#ssh" do
-    it "should have an ssh command" do
-      expect(cli).to respond_to(:ssh)
-    end
-
-    it "should execute shell on production target by default" do
-      expect(target).to receive(:exec!).with("exec $SHELL -l", home: false)
-
-      cli.ssh
-    end
-
-    it "should execute shell with home option when specified" do
-      allow(cli).to receive(:options).and_return({ home: true })
-      expect(target).to receive(:exec!).with("exec $SHELL -l", home: true)
-
-      cli.ssh
-    end
-
-    it "should connect to specified target" do
-      staging_server = double("staging")
-      allow(config).to receive(:[]).with(:staging).and_return(staging_server)
-      expect(staging_server).to receive(:exec!).with("exec $SHELL -l", home: false)
-
-      cli.ssh(:staging)
-    end
-  end
-end