bard 1.4.8 → 1.4.9

data/spec/bard/git_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require "bard/git"
+
+describe Bard::Git do
+  describe ".current_branch" do
+    it "should return the current branch" do
+      allow(Bard::Git).to receive(:`).with("git symbolic-ref HEAD 2>&1").and_return("refs/heads/master\n")
+      expect(Bard::Git.current_branch).to eq("master")
+    end
+
+    it "should return false if not on a branch" do
+      allow(Bard::Git).to receive(:`).with("git symbolic-ref HEAD 2>&1").and_return("fatal: ref HEAD is not a symbolic ref\n")
+      expect(Bard::Git.current_branch).to be_falsey
+    end
+  end
+
+  describe ".fast_forward_merge?" do
+    it "should return true if the root is an ancestor of the branch" do
+      allow(Bard::Git).to receive(:sha_of).with("root").and_return("root_sha")
+      allow(Bard::Git).to receive(:sha_of).with("branch").and_return("branch_sha")
+      allow(Bard::Git).to receive(:`).with("git merge-base root_sha branch_sha").and_return("root_sha\n")
+      expect(Bard::Git.fast_forward_merge?("root", "branch")).to be_truthy
+    end
+
+    it "should return false if the root is not an ancestor of the branch" do
+      allow(Bard::Git).to receive(:sha_of).with("root").and_return("root_sha")
+      allow(Bard::Git).to receive(:sha_of).with("branch").and_return("branch_sha")
+      allow(Bard::Git).to receive(:`).with("git merge-base root_sha branch_sha").and_return("other_sha\n")
+      expect(Bard::Git.fast_forward_merge?("root", "branch")).to be_falsey
+    end
+  end
+
+  describe ".up_to_date_with_remote?" do
+    it "should return true if the local branch is up to date with the remote" do
+      allow(Bard::Git).to receive(:sha_of).with("branch").and_return("sha")
+      allow(Bard::Git).to receive(:sha_of).with("origin/branch").and_return("sha")
+      expect(Bard::Git.up_to_date_with_remote?("branch")).to be_truthy
+    end
+
+    it "should return false if the local branch is not up to date with the remote" do
+      allow(Bard::Git).to receive(:sha_of).with("branch").and_return("sha1")
+      allow(Bard::Git).to receive(:sha_of).with("origin/branch").and_return("sha2")
+      expect(Bard::Git.up_to_date_with_remote?("branch")).to be_falsey
+    end
+  end
+
+  describe ".sha_of" do
+    it "should return the sha of a ref" do
+      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null").and_return("sha\n")
+      allow(Bard::Git).to receive(:command_succeeded?).and_return(true)
+      expect(Bard::Git.sha_of("ref")).to eq("sha")
+    end
+
+    it "should return nil if the ref does not exist" do
+      allow(Bard::Git).to receive(:`).with("git rev-parse ref 2>/dev/null").and_return("ref: fatal: ambiguous argument 'ref': unknown revision or path not in the working tree.\n")
+      allow(Bard::Git).to receive(:command_succeeded?).and_return(false)
+      expect(Bard::Git.sha_of("ref")).to be_nil
+    end
+  end
+end
+

data/spec/bard/github_pages_spec.rb

@@ -0,0 +1,80 @@
+require "spec_helper"
+require "bard/github_pages"
+
+describe Bard::GithubPages do
+  let(:server) { double("server", ping: ["https://example.com"]) }
+  let(:github_pages) { Bard::GithubPages.new(double) }
+
+  before do
+    allow(Bard::Git).to receive(:sha_of).and_return("abc123")
+    allow(Bard::Git).to receive(:current_branch).and_return("main")
+    allow(github_pages).to receive(:system)
+    allow(github_pages).to receive(:run!)
+    allow(github_pages).to receive(:puts)
+  end
+
+  describe "#deploy" do
+    it "performs the deployment steps" do
+      expect(github_pages).to receive(:build_site)
+      expect(github_pages).to receive(:create_tree_from_build).and_return("tree123")
+      expect(github_pages).to receive(:create_commit).with("tree123").and_return("commit123")
+      expect(github_pages).to receive(:commit_and_push).with("commit123")
+
+      github_pages.deploy(server)
+    end
+
+    it "sets instance variables" do
+      allow(github_pages).to receive(:build_site)
+      allow(github_pages).to receive(:create_tree_from_build).and_return("tree123")
+      allow(github_pages).to receive(:create_commit).and_return("commit123")
+      allow(github_pages).to receive(:commit_and_push)
+
+      github_pages.deploy(server)
+
+      expect(github_pages.instance_variable_get(:@sha)).to eq("abc123")
+      expect(github_pages.instance_variable_get(:@build_dir)).to eq("tmp/github-build-abc123")
+      expect(github_pages.instance_variable_get(:@branch)).to eq("gh-pages")
+      expect(github_pages.instance_variable_get(:@domain)).to eq("example.com")
+    end
+  end
+
+  describe "#get_parent_commit" do
+    it "returns the sha of the gh-pages branch" do
+      github_pages.instance_variable_set(:@branch, "gh-pages")
+      expect(Bard::Git).to receive(:sha_of).with("gh-pages^{commit}")
+      github_pages.send(:get_parent_commit)
+    end
+  end
+
+  describe "#branch_exists?" do
+    it "checks if branch exists using git show-ref" do
+      github_pages.instance_variable_set(:@branch, "gh-pages")
+      expect(github_pages).to receive(:system).with("git show-ref --verify --quiet refs/heads/gh-pages")
+      github_pages.send(:branch_exists?)
+    end
+  end
+
+  describe "#commit_and_push" do
+    before do
+      github_pages.instance_variable_set(:@branch, "gh-pages")
+    end
+
+    context "when branch exists" do
+      it "updates the ref and pushes" do
+        allow(github_pages).to receive(:branch_exists?).and_return(true)
+        expect(github_pages).to receive(:run!).with("git update-ref refs/heads/gh-pages commit123")
+        expect(github_pages).to receive(:run!).with("git push -f origin gh-pages:refs/heads/gh-pages")
+        github_pages.send(:commit_and_push, "commit123")
+      end
+    end
+
+    context "when branch doesn't exist" do
+      it "creates the branch and pushes" do
+        allow(github_pages).to receive(:branch_exists?).and_return(false)
+        expect(github_pages).to receive(:run!).with("git branch gh-pages commit123")
+        expect(github_pages).to receive(:run!).with("git push -f origin gh-pages:refs/heads/gh-pages")
+        github_pages.send(:commit_and_push, "commit123")
+      end
+    end
+  end
+end

data/spec/bard/github_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+require "bard/github"
+
+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:botandrose/bard").and_return("github-apikey|12345")
+  end
+
+  describe "#get" do
+    it "should make a GET request to the GitHub API" do
+      stub_request(:get, "https://api.github.com/repos/botandrosedesign/test-project/path").to_return(body: "{}")
+      github.get("path")
+    end
+  end
+
+  describe "#post" do
+    it "should make a POST request to the GitHub API" do
+      stub_request(:post, "https://api.github.com/repos/botandrosedesign/test-project/path").with(body: "{\"foo\":\"bar\"}").to_return(body: "{}")
+      github.post("path", { foo: "bar" })
+    end
+  end
+
+  describe "#put" do
+    it "should make a PUT request to the GitHub API" do
+      stub_request(:put, "https://api.github.com/repos/botandrosedesign/test-project/path").with(body: "{\"foo\":\"bar\"}").to_return(body: "{}")
+      github.put("path", { foo: "bar" })
+    end
+  end
+
+  describe "#patch" do
+    it "should make a PATCH request to the GitHub API" do
+      stub_request(:patch, "https://api.github.com/repos/botandrosedesign/test-project/path").with(body: "{\"foo\":\"bar\"}").to_return(body: "{}")
+      github.patch("path", { foo: "bar" })
+    end
+  end
+
+  describe "#delete" do
+    it "should make a DELETE request to the GitHub API" do
+      stub_request(:delete, "https://api.github.com/repos/botandrosedesign/test-project").with(body: "{\"foo\":\"bar\"}").to_return(body: "{}")
+      github.delete(nil, { foo: "bar" })
+    end
+  end
+end

data/spec/bard/ping_spec.rb

@@ -0,0 +1,31 @@
+require "spec_helper"
+require "bard/ping"
+
+describe Bard::Ping do
+  let(:server) { double("server", ping: ["http://example.com"]) }
+
+  context "when the server is reachable" do
+    it "should return an empty array" do
+      allow(Net::HTTP).to receive(:get_response).and_return(Net::HTTPSuccess.new(1.0, "200", "OK"))
+      expect(Bard::Ping.call(server)).to be_empty
+    end
+  end
+
+  context "when the server is not reachable" do
+    it "should return the url" do
+      allow(Net::HTTP).to receive(:get_response).and_return(Net::HTTPNotFound.new(1.0, "404", "Not Found"))
+      expect(Bard::Ping.call(server)).to eq(["http://example.com"])
+    end
+  end
+
+  context "when there is a redirect" do
+    it "should follow the redirect and return an empty array" do
+      redirect_response = Net::HTTPRedirection.new(1.0, "301", "Moved Permanently")
+      redirect_response["location"] = "http://example.com/new"
+      success_response = Net::HTTPSuccess.new(1.0, "200", "OK")
+      allow(Net::HTTP).to receive(:get_response).with(URI("http://example.com")).and_return(redirect_response)
+      allow(Net::HTTP).to receive(:get_response).with(URI("http://example.com/new")).and_return(success_response)
+      expect(Bard::Ping.call(server)).to be_empty
+    end
+  end
+end

data/spec/bard/provision/app_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/app"
+
+describe Bard::Provision::App do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:app) { Bard::Provision::App.new(config, ssh_url) }
+
+  before do
+    allow(app).to receive(:provision_server).and_return(provision_server)
+    allow(app).to receive(:print)
+    allow(app).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "runs bin/setup on the server" do
+      expect(provision_server).to receive(:run!).with("bin/setup")
+
+      app.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+
+      expect(app).to receive(:print).with("App:")
+      expect(app).to receive(:puts).with(" ✓")
+
+      app.call
+    end
+  end
+end

data/spec/bard/provision/apt_spec.rb

@@ -0,0 +1,39 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/apt"
+
+describe Bard::Provision::Apt do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:apt) { Bard::Provision::Apt.new(config, ssh_url) }
+
+  before do
+    allow(apt).to receive(:provision_server).and_return(provision_server)
+    allow(apt).to receive(:print)
+    allow(apt).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "updates and installs packages on the server" do
+      expected_commands = [
+        %(echo "\\$nrconf{restart} = \\"a\\";" | sudo tee /etc/needrestart/conf.d/90-autorestart.conf),
+        "sudo apt-get update -y",
+        "sudo apt-get upgrade -y",
+        "sudo apt-get install -y curl"
+      ].join("; ")
+
+      expect(provision_server).to receive(:run!).with(expected_commands, home: true)
+
+      apt.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(apt).to receive(:print).with("Apt:")
+      expect(apt).to receive(:puts).with(" ✓")
+
+      apt.call
+    end
+  end
+end

data/spec/bard/provision/authorizedkeys_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/authorizedkeys"
+
+describe Bard::Provision::AuthorizedKeys do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:authorized_keys) { Bard::Provision::AuthorizedKeys.new(config, ssh_url) }
+
+  before do
+    allow(authorized_keys).to receive(:provision_server).and_return(provision_server)
+    allow(authorized_keys).to receive(:print)
+    allow(authorized_keys).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "adds authorized keys to the server" do
+      expect(provision_server).to receive(:run!).at_least(:once).with(/grep -F -q/, home: true)
+
+      authorized_keys.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(authorized_keys).to receive(:print).with("Authorized Keys:")
+      expect(authorized_keys).to receive(:puts).with(" ✓")
+
+      authorized_keys.call
+    end
+  end
+
+  describe "KEYS constant" do
+    it "should have predefined SSH keys" do
+      expect(Bard::Provision::AuthorizedKeys::KEYS).to be_a(Hash)
+      expect(Bard::Provision::AuthorizedKeys::KEYS).not_to be_empty
+      expect(Bard::Provision::AuthorizedKeys::KEYS.keys.first).to match(/@/)
+    end
+  end
+end

data/spec/bard/provision/data_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/data"
+
+describe Bard::Provision::Data do
+  let(:server) { double("server", key: :production) }
+  let(:config) { double("config", data: ["uploads", "assets"]) }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:data_provisioner) { Bard::Provision::Data.new(config, ssh_url) }
+
+  before do
+    allow(data_provisioner).to receive(:server).and_return(server)
+    allow(data_provisioner).to receive(:config).and_return(config)
+    allow(data_provisioner).to receive(:provision_server).and_return(provision_server)
+    allow(data_provisioner).to receive(:print)
+    allow(data_provisioner).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "dumps, transfers, and loads database data" do
+      expect(server).to receive(:run!).with("bin/rake db:dump")
+      expect(server).to receive(:copy_file).with("db/data.sql.gz", to: provision_server, verbose: false)
+      expect(provision_server).to receive(:run!).with("bin/rake db:load")
+
+      allow(server).to receive(:copy_dir)
+
+      data_provisioner.call
+    end
+
+    it "synchronizes configured data directories" do
+      allow(server).to receive(:run!)
+      allow(server).to receive(:copy_file)
+      allow(provision_server).to receive(:run!)
+
+      expect(server).to receive(:copy_dir).with("uploads", to: provision_server, verbose: false)
+      expect(server).to receive(:copy_dir).with("assets", to: provision_server, verbose: false)
+
+      data_provisioner.call
+    end
+
+    it "prints status messages" do
+      allow(server).to receive(:run!)
+      allow(server).to receive(:copy_file)
+      allow(server).to receive(:copy_dir)
+      allow(provision_server).to receive(:run!)
+
+      expect(data_provisioner).to receive(:print).with("Data:")
+      expect(data_provisioner).to receive(:puts).with(" ✓")
+
+      data_provisioner.call
+    end
+  end
+end

data/spec/bard/provision/deploy_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/deploy"
+
+describe Bard::Provision::Deploy do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:deploy) { Bard::Provision::Deploy.new(config, ssh_url) }
+
+  before do
+    allow(deploy).to receive(:provision_server).and_return(provision_server)
+    allow(deploy).to receive(:print)
+    allow(deploy).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "runs bin/setup on the server" do
+      expect(provision_server).to receive(:run!).with("bin/setup")
+
+      deploy.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+
+      expect(deploy).to receive(:print).with("Deploy:")
+      expect(deploy).to receive(:puts).with(" ✓")
+
+      deploy.call
+    end
+  end
+end

data/spec/bard/provision/http_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/http"
+
+describe Bard::Provision::HTTP do
+  let(:server) { double("server", ping: ["https://example.com"]) }
+  let(:config) { { production: server } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:http) { Bard::Provision::HTTP.new(config, ssh_url) }
+
+  before do
+    allow(http).to receive(:server).and_return(server)
+    allow(http).to receive(:provision_server).and_return(provision_server)
+    allow(provision_server).to receive_message_chain(:ssh_uri, :host).and_return("192.168.1.100")
+    allow(http).to receive(:print)
+    allow(http).to receive(:puts)
+    allow(http).to receive(:system)
+  end
+
+  describe "#call" do
+    context "when HTTP test passes" do
+      it "shows success message" do
+        allow(http).to receive(:system).and_return(true)
+
+        expect(http).to receive(:puts).with(" ✓")
+
+        http.call
+      end
+    end
+
+    context "when HTTP test fails" do
+      it "shows failure message" do
+        allow(http).to receive(:system).and_return(false)
+
+        expect(http).to receive(:puts).with(" !!! not serving a rails app from 192.168.1.100")
+
+        http.call
+      end
+    end
+
+    it "prints status header" do
+      allow(http).to receive(:system).and_return(true)
+
+      expect(http).to receive(:print).with("HTTP:")
+
+      http.call
+    end
+
+    it "tests the correct URL" do
+      expected_command = /curl -s --resolve example\.com:80:192\.168\.1\.100 http:\/\/example\.com/
+      expect(http).to receive(:system).with(expected_command)
+
+      http.call
+    end
+  end
+end

data/spec/bard/provision/logrotation_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/logrotation"
+
+describe Bard::Provision::LogRotation do
+  let(:server) { double("server", project_name: "test_app") }
+  let(:config) { { production: server } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:logrotation) { Bard::Provision::LogRotation.new(config, ssh_url) }
+
+  before do
+    allow(logrotation).to receive(:server).and_return(server)
+    allow(logrotation).to receive(:provision_server).and_return(provision_server)
+    allow(logrotation).to receive(:print)
+    allow(logrotation).to receive(:puts)
+  end
+
+  describe "#call" do
+    it "sets up log rotation config on the server" do
+      expect(provision_server).to receive(:run!).with(/file=\/etc\/logrotate\.d\/test_app/, quiet: true)
+
+      logrotation.call
+    end
+
+    it "prints status messages" do
+      allow(provision_server).to receive(:run!)
+      expect(logrotation).to receive(:print).with("Log Rotation:")
+      expect(logrotation).to receive(:puts).with(" ✓")
+
+      logrotation.call
+    end
+  end
+end

data/spec/bard/provision/masterkey_spec.rb

@@ -0,0 +1,63 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/masterkey"
+
+describe Bard::Provision::MasterKey do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:master_key) { Bard::Provision::MasterKey.new(config, ssh_url) }
+
+  before do
+    allow(master_key).to receive(:provision_server).and_return(provision_server)
+    allow(master_key).to receive(:print)
+    allow(master_key).to receive(:puts)
+  end
+
+  describe "#call" do
+    context "when master.key exists locally" do
+      before do
+        allow(File).to receive(:exist?).with("config/master.key").and_return(true)
+      end
+
+      it "uploads master.key if not present on server" do
+        allow(provision_server).to receive(:run).with("[ -f config/master.key ]", quiet: true).and_return(false)
+
+        copy_double = double("copy")
+        expect(Bard::Copy).to receive(:new).with("config/master.key").and_return(copy_double)
+        expect(copy_double).to receive(:scp_using_local).with(:to, provision_server)
+
+        master_key.call
+      end
+
+      it "skips upload if master.key already exists on server" do
+        allow(provision_server).to receive(:run).with("[ -f config/master.key ]", quiet: true).and_return(true)
+
+        expect(Bard::Copy).not_to receive(:new)
+
+        master_key.call
+      end
+    end
+
+    context "when master.key doesn't exist locally" do
+      before do
+        allow(File).to receive(:exist?).with("config/master.key").and_return(false)
+      end
+
+      it "skips the upload" do
+        expect(Bard::Copy).not_to receive(:new)
+
+        master_key.call
+      end
+    end
+
+    it "prints status messages" do
+      allow(File).to receive(:exist?).and_return(false)
+
+      expect(master_key).to receive(:print).with("Master Key:")
+      expect(master_key).to receive(:puts).with(" ✓")
+
+      master_key.call
+    end
+  end
+end

data/spec/bard/provision/mysql_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "bard/provision"
+require "bard/provision/mysql"
+
+describe Bard::Provision::MySQL do
+  let(:config) { { production: double("production") } }
+  let(:ssh_url) { "user@example.com" }
+  let(:provision_server) { double("provision_server") }
+  let(:mysql) { Bard::Provision::MySQL.new(config, ssh_url) }
+
+  before do
+    allow(mysql).to receive(:provision_server).and_return(provision_server)
+    allow(mysql).to receive(:print)
+    allow(mysql).to receive(:puts)
+  end
+
+  describe "#call" do
+    context "when MySQL is not responding" do
+      it "installs MySQL" do
+        allow(mysql).to receive(:mysql_responding?).and_return(false)
+
+        expect(provision_server).to receive(:run!).with(/sudo apt-get install -y mysql-server/, home: true)
+
+        mysql.call
+      end
+    end
+
+    context "when MySQL is already responding" do
+      it "skips installation" do
+        allow(mysql).to receive(:mysql_responding?).and_return(true)
+
+        expect(provision_server).not_to receive(:run!)
+
+        mysql.call
+      end
+    end
+
+    it "prints status messages" do
+      allow(mysql).to receive(:mysql_responding?).and_return(true)
+
+      expect(mysql).to receive(:print).with("MySQL:")
+      expect(mysql).to receive(:puts).with(" ✓")
+
+      mysql.call
+    end
+  end
+
+  describe "#mysql_responding?" do
+    it "checks if MySQL service is active" do
+      expect(provision_server).to receive(:run).with("sudo systemctl is-active --quiet mysql", home: true, quiet: true)
+
+      mysql.mysql_responding?
+    end
+  end
+end