bard 2.0.0.beta → 2.0.1

data/spec/bard/provision/logrotation_spec.rb

@@ -1,34 +0,0 @@
-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

@@ -1,63 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

data/spec/bard/provision/passenger_spec.rb

@@ -1,81 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/passenger"
-
-describe Bard::Provision::Passenger 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(:passenger) { Bard::Provision::Passenger.new(config, ssh_url) }
-
-  before do
-    allow(passenger).to receive(:server).and_return(server)
-    allow(passenger).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(passenger).to receive(:print)
-    allow(passenger).to receive(:puts)
-    allow(passenger).to receive(:system)
-  end
-
-  describe "#call" do
-    context "when HTTP is not responding" do
-      it "installs nginx and passenger" do
-        allow(passenger).to receive(:http_responding?).and_return(false)
-        allow(passenger).to receive(:app_configured?).and_return(true)
-
-        expect(provision_server).to receive(:run!).with(/grep -qxF.*RAILS_ENV/, home: true)
-
-        passenger.call
-      end
-    end
-
-    context "when app is not configured" do
-      it "creates nginx config" do
-        allow(passenger).to receive(:http_responding?).and_return(true)
-        allow(passenger).to receive(:app_configured?).and_return(false)
-
-        expect(provision_server).to receive(:run!).with("bard setup")
-
-        passenger.call
-      end
-    end
-
-    context "when everything is already set up" do
-      it "skips installation and configuration" do
-        allow(passenger).to receive(:http_responding?).and_return(true)
-        allow(passenger).to receive(:app_configured?).and_return(true)
-
-        expect(provision_server).not_to receive(:run!)
-
-        passenger.call
-      end
-    end
-
-    it "prints status messages" do
-      allow(passenger).to receive(:http_responding?).and_return(true)
-      allow(passenger).to receive(:app_configured?).and_return(true)
-
-      expect(passenger).to receive(:print).with("Passenger:")
-      expect(passenger).to receive(:puts).with(" ✓")
-
-      passenger.call
-    end
-  end
-
-  describe "#http_responding?" do
-    it "checks if port 80 is responding" do
-      expect(passenger).to receive(:system).with("nc -zv 192.168.1.100 80 2>/dev/null")
-
-      passenger.http_responding?
-    end
-  end
-
-  describe "#app_configured?" do
-    it "checks if nginx config exists for the app" do
-      expect(provision_server).to receive(:run).with("[ -f /etc/nginx/sites-enabled/test_app ]", quiet: true)
-
-      passenger.app_configured?
-    end
-  end
-end

data/spec/bard/provision/repo_spec.rb

@@ -1,208 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/repo"
-
-describe Bard::Provision::Repo do
-  let(:ssh_uri) { double("ssh_uri", user: "deploy", host: "example.com") }
-  let(:server) { double("server", ssh_uri: ssh_uri, project_name: "test_project") }
-  let(:config) { { production: server } }
-  let(:ssh_url) { "deploy@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:github_api) { double("github_api") }
-  let(:repo_provisioner) { Bard::Provision::Repo.new(config, ssh_url) }
-
-  before do
-    allow(repo_provisioner).to receive(:server).and_return(server)
-    allow(repo_provisioner).to receive(:provision_server).and_return(provision_server)
-    allow(repo_provisioner).to receive(:print)
-    allow(repo_provisioner).to receive(:puts)
-    allow(Bard::Github).to receive(:new).and_return(github_api)
-  end
-
-  describe "#call" do
-    context "when repository is already cloned" do
-      context "when not on latest master" do
-        it "updates to latest master" do
-          allow(repo_provisioner).to receive(:already_cloned?).and_return(true)
-          allow(repo_provisioner).to receive(:on_latest_master?).and_return(false)
-
-          expect(repo_provisioner).to receive(:update_to_latest_master!)
-          expect(github_api).not_to receive(:add_deploy_key)
-
-          repo_provisioner.call
-        end
-
-        it "prints status message when updating to latest master" do
-          allow(repo_provisioner).to receive(:already_cloned?).and_return(true)
-          allow(repo_provisioner).to receive(:on_latest_master?).and_return(false)
-          allow(repo_provisioner).to receive(:update_to_latest_master!)
-
-          expect(repo_provisioner).to receive(:print).with("Repo:")
-          expect(repo_provisioner).to receive(:print).with(" Updating to latest master,")
-          expect(repo_provisioner).to receive(:puts).with(" ✓")
-
-          repo_provisioner.call
-        end
-      end
-
-      context "when already on latest master" do
-        it "skips update" do
-          allow(repo_provisioner).to receive(:already_cloned?).and_return(true)
-          allow(repo_provisioner).to receive(:on_latest_master?).and_return(true)
-
-          expect(repo_provisioner).not_to receive(:update_to_latest_master!)
-          expect(github_api).not_to receive(:add_deploy_key)
-
-          repo_provisioner.call
-        end
-
-        it "only prints repo header and checkbox" do
-          allow(repo_provisioner).to receive(:already_cloned?).and_return(true)
-          allow(repo_provisioner).to receive(:on_latest_master?).and_return(true)
-
-          expect(repo_provisioner).to receive(:print).with("Repo:")
-          expect(repo_provisioner).not_to receive(:print).with(" Updating to latest master,")
-          expect(repo_provisioner).to receive(:puts).with(" ✓")
-
-          repo_provisioner.call
-        end
-      end
-    end
-
-    context "when repository is not cloned but can be cloned" do
-      it "clones the repository directly" do
-        allow(repo_provisioner).to receive(:already_cloned?).and_return(false)
-        allow(repo_provisioner).to receive(:can_clone_project?).and_return(true)
-
-        expect(provision_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project", home: true)
-        expect(github_api).not_to receive(:add_deploy_key)
-
-        repo_provisioner.call
-      end
-    end
-
-    context "when repository cannot be cloned and SSH keypair exists" do
-      it "adds deploy key and clones repository" do
-        allow(repo_provisioner).to receive(:already_cloned?).and_return(false)
-        allow(repo_provisioner).to receive(:can_clone_project?).and_return(false)
-        allow(repo_provisioner).to receive(:ssh_keypair?).and_return(true)
-        allow(provision_server).to receive(:run).with("cat ~/.ssh/id_rsa.pub", home: true).and_return("ssh-rsa AAAAB3...")
-
-        expect(github_api).to receive(:add_deploy_key).with(title: "deploy@example.com", key: "ssh-rsa AAAAB3...")
-        expect(provision_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project", home: true)
-
-        repo_provisioner.call
-      end
-    end
-
-    context "when repository cannot be cloned and no SSH keypair exists" do
-      it "generates keypair, adds deploy key, and clones repository" do
-        allow(repo_provisioner).to receive(:already_cloned?).and_return(false)
-        allow(repo_provisioner).to receive(:can_clone_project?).and_return(false)
-        allow(repo_provisioner).to receive(:ssh_keypair?).and_return(false)
-        allow(provision_server).to receive(:run).with("cat ~/.ssh/id_rsa.pub", home: true).and_return("ssh-rsa AAAAB3...")
-
-        expect(provision_server).to receive(:run!).with('ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -q -N ""', home: true)
-        expect(github_api).to receive(:add_deploy_key).with(title: "deploy@example.com", key: "ssh-rsa AAAAB3...")
-        expect(provision_server).to receive(:run!).with("git clone git@github.com:botandrosedesign/test_project", home: true)
-
-        repo_provisioner.call
-      end
-
-      it "prints status messages during setup" do
-        allow(repo_provisioner).to receive(:already_cloned?).and_return(false)
-        allow(repo_provisioner).to receive(:can_clone_project?).and_return(false)
-        allow(repo_provisioner).to receive(:ssh_keypair?).and_return(false)
-        allow(provision_server).to receive(:run).and_return("ssh-rsa AAAAB3...")
-        allow(provision_server).to receive(:run!)
-        allow(github_api).to receive(:add_deploy_key)
-
-        expect(repo_provisioner).to receive(:print).with("Repo:")
-        expect(repo_provisioner).to receive(:print).with(" Generating keypair in ~/.ssh,")
-        expect(repo_provisioner).to receive(:print).with(" Add public key to GitHub repo deploy keys,")
-        expect(repo_provisioner).to receive(:print).with(" Cloning repo,")
-        expect(repo_provisioner).to receive(:puts).with(" ✓")
-
-        repo_provisioner.call
-      end
-    end
-
-    it "always prints success message" do
-      allow(repo_provisioner).to receive(:already_cloned?).and_return(true)
-      allow(repo_provisioner).to receive(:on_latest_master?).and_return(true)
-
-      expect(repo_provisioner).to receive(:print).with("Repo:")
-      expect(repo_provisioner).to receive(:puts).with(" ✓")
-
-      repo_provisioner.call
-    end
-  end
-
-  describe "private methods" do
-    describe "#ssh_keypair?" do
-      it "checks if SSH public key exists" do
-        expect(provision_server).to receive(:run).with("[ -f ~/.ssh/id_rsa.pub ]", home: true, quiet: true)
-
-        repo_provisioner.send(:ssh_keypair?)
-      end
-    end
-
-    describe "#already_cloned?" do
-      it "checks if git directory exists" do
-        expect(provision_server).to receive(:run).with("[ -d ~/test_project/.git ]", home: true, quiet: true)
-
-        repo_provisioner.send(:already_cloned?)
-      end
-    end
-
-    describe "#can_clone_project?" do
-      it "tests if repository can be cloned" do
-        expected_commands = [
-          "needle=$(ssh-keyscan -t ed25519 github.com 2>/dev/null | cut -d \" \" -f 2-3)",
-          "grep -q \"$needle\" ~/.ssh/known_hosts || ssh-keyscan -H github.com >> ~/.ssh/known_hosts 2>/dev/null",
-          "git ls-remote git@github.com:botandrosedesign/test_project"
-        ].join("; ")
-
-        expect(provision_server).to receive(:run).with(expected_commands, home: true, quiet: true)
-
-        repo_provisioner.send(:can_clone_project?)
-      end
-    end
-
-    describe "#project_name" do
-      it "returns the server's project name" do
-        expect(repo_provisioner.send(:project_name)).to eq("test_project")
-      end
-    end
-
-    describe "#on_latest_master?" do
-      it "checks if current HEAD matches origin/master after fetching" do
-        expected_command = "cd ~/test_project && git fetch origin && [ $(git rev-parse HEAD) = $(git rev-parse origin/master) ]"
-        expect(provision_server).to receive(:run).with(expected_command, home: true, quiet: true)
-
-        repo_provisioner.send(:on_latest_master?)
-      end
-
-      it "returns true when on latest master" do
-        allow(provision_server).to receive(:run).and_return(true)
-
-        expect(repo_provisioner.send(:on_latest_master?)).to be true
-      end
-
-      it "returns false when not on latest master" do
-        allow(provision_server).to receive(:run).and_return(false)
-
-        expect(repo_provisioner.send(:on_latest_master?)).to be false
-      end
-    end
-
-    describe "#update_to_latest_master!" do
-      it "checks out master and resets to origin/master" do
-        expected_command = "cd ~/test_project && git checkout master && git reset --hard origin/master"
-        expect(provision_server).to receive(:run!).with(expected_command, home: true)
-
-        repo_provisioner.send(:update_to_latest_master!)
-      end
-    end
-  end
-end

data/spec/bard/provision/rvm_spec.rb

@@ -1,49 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/rvm"
-
-describe Bard::Provision::RVM do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:rvm) { Bard::Provision::RVM.new(config, ssh_url) }
-
-  before do
-    allow(rvm).to receive(:provision_server).and_return(provision_server)
-    allow(rvm).to receive(:print)
-    allow(rvm).to receive(:puts)
-    allow(File).to receive(:read).with(".ruby-version").and_return("3.2.0\n")
-  end
-
-  describe "#call" do
-    context "when RVM is not installed" do
-      it "installs RVM and Ruby" do
-        allow(provision_server).to receive(:run).with("[ -d ~/.rvm ]", quiet: true).and_return(false)
-
-        expect(provision_server).to receive(:run!).with(/sed -i.*bashrc/)
-        expect(provision_server).to receive(:run!).with("rvm install 3.2.0")
-
-        rvm.call
-      end
-    end
-
-    context "when RVM is already installed" do
-      it "skips installation" do
-        allow(provision_server).to receive(:run).with("[ -d ~/.rvm ]", quiet: true).and_return(true)
-
-        expect(provision_server).not_to receive(:run!)
-
-        rvm.call
-      end
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run).and_return(true)
-
-      expect(rvm).to receive(:print).with("RVM:")
-      expect(rvm).to receive(:puts).with(" ✓")
-
-      rvm.call
-    end
-  end
-end