bard 2.0.0.beta → 2.0.1

data/spec/bard/provision/ssh_spec.rb

@@ -1,229 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/ssh"
-
-describe Bard::Provision::SSH do
-  let(:ssh_uri) { double("ssh_uri", host: "example.com", port: 2222) }
-  let(:provision_ssh_uri) { double("provision_ssh_uri", host: "example.com", port: nil) }
-  let(:server) { double("server", ssh_uri: ssh_uri) }
-  let(:config) { { production: server } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server", ssh_uri: provision_ssh_uri) }
-  let(:ssh_provisioner) { Bard::Provision::SSH.new(config, ssh_url) }
-
-  before do
-    allow(ssh_provisioner).to receive(:server).and_return(server)
-    allow(ssh_provisioner).to receive(:provision_server).and_return(provision_server)
-    allow(ssh_provisioner).to receive(:print)
-    allow(ssh_provisioner).to receive(:puts)
-    allow(ssh_provisioner).to receive(:system)
-  end
-
-  describe "#call" do
-    context "when SSH is already available on target port" do
-      it "skips port reconfiguration but checks known hosts" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).with(provision_ssh_uri).and_return(true)
-
-        expect(provision_server).not_to receive(:run!)
-
-        ssh_provisioner.call
-      end
-
-      it "adds to known hosts if not present" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).with(provision_ssh_uri).and_return(false)
-
-        expect(ssh_provisioner).to receive(:add_ssh_known_host!).with(provision_ssh_uri)
-
-        ssh_provisioner.call
-      end
-    end
-
-    context "when SSH is not available on target port but available on default port" do
-      it "reconfigures SSH port and adds to known hosts" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).with(provision_ssh_uri).and_return(false)
-
-        expect(ssh_provisioner).to receive(:add_ssh_known_host!).with(provision_ssh_uri).twice
-        expect(provision_server).to receive(:run!).with(
-          'echo "Port 2222" | sudo tee /etc/ssh/sshd_config.d/port_2222.conf; sudo service ssh restart',
-          home: true
-        )
-
-        ssh_provisioner.call
-      end
-
-      it "prints status messages during reconfiguration" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).and_return(false)
-        allow(ssh_provisioner).to receive(:add_ssh_known_host!)
-        allow(provision_server).to receive(:run!)
-
-        expect(ssh_provisioner).to receive(:print).with("SSH:")
-        expect(ssh_provisioner).to receive(:print).with(" Adding known host,")
-        expect(ssh_provisioner).to receive(:print).with(" Reconfiguring port to 2222,")
-        expect(ssh_provisioner).to receive(:print).with(" Adding known host,")
-        expect(ssh_provisioner).to receive(:puts).with(" ✓")
-
-        ssh_provisioner.call
-      end
-    end
-
-    context "when SSH is not available on either port" do
-      it "raises an error" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri).and_return(false)
-
-        expect { ssh_provisioner.call }.to raise_error("can't find SSH on port 2222 or 22")
-      end
-    end
-
-    context "when password authentication is enabled" do
-      it "disables password authentication" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).and_return(true)
-
-        expect(ssh_provisioner).to receive(:disable_password_auth!)
-
-        ssh_provisioner.call
-      end
-
-      it "prints status message when disabling password authentication" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(true)
-        allow(ssh_provisioner).to receive(:disable_password_auth!)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).and_return(true)
-
-        expect(ssh_provisioner).to receive(:print).with("SSH:")
-        expect(ssh_provisioner).to receive(:print).with(" Disabling password authentication,")
-        expect(ssh_provisioner).to receive(:puts).with(" ✓")
-
-        ssh_provisioner.call
-      end
-    end
-
-    context "when password authentication is already disabled" do
-      it "skips disabling password authentication" do
-        allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-        allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-        allow(ssh_provisioner).to receive(:ssh_known_host?).and_return(true)
-
-        expect(ssh_provisioner).not_to receive(:disable_password_auth!)
-
-        ssh_provisioner.call
-      end
-    end
-
-    it "updates the SSH URL with the target port" do
-      allow(ssh_provisioner).to receive(:password_auth_enabled?).and_return(false)
-      allow(ssh_provisioner).to receive(:ssh_available?).with(provision_ssh_uri, port: 2222).and_return(true)
-      allow(ssh_provisioner).to receive(:ssh_known_host?).and_return(true)
-
-      ssh_provisioner.call
-    end
-  end
-
-  describe "private methods" do
-    describe "#target_port" do
-      it "returns the server's SSH port" do
-        expect(ssh_provisioner.send(:target_port)).to eq(2222)
-      end
-
-      it "defaults to 22 if no port is specified" do
-        allow(ssh_uri).to receive(:port).and_return(nil)
-        expect(ssh_provisioner.send(:target_port)).to eq(22)
-      end
-    end
-
-    describe "#ssh_available?" do
-      it "tests SSH connectivity on specified port" do
-        expect(ssh_provisioner).to receive(:system).with("nc -zv example.com 2222 2>/dev/null")
-
-        ssh_provisioner.send(:ssh_available?, provision_ssh_uri, port: 2222)
-      end
-
-      it "uses SSH URI port if no port specified" do
-        allow(provision_ssh_uri).to receive(:port).and_return(2222)
-        expect(ssh_provisioner).to receive(:system).with("nc -zv example.com 2222 2>/dev/null")
-
-        ssh_provisioner.send(:ssh_available?, provision_ssh_uri)
-      end
-
-      it "defaults to port 22 if no port in URI or parameter" do
-        expect(ssh_provisioner).to receive(:system).with("nc -zv example.com 22 2>/dev/null")
-
-        ssh_provisioner.send(:ssh_available?, provision_ssh_uri)
-      end
-    end
-
-    describe "#ssh_known_host?" do
-      it "checks if host is in known_hosts file" do
-        expected_command = 'grep -q "$(ssh-keyscan -t ed25519 -p22 example.com 2>/dev/null | cut -d \' \' -f 2-3)" ~/.ssh/known_hosts'
-        expect(ssh_provisioner).to receive(:system).with(expected_command)
-
-        ssh_provisioner.send(:ssh_known_host?, provision_ssh_uri)
-      end
-    end
-
-    describe "#add_ssh_known_host!" do
-      it "adds host to known_hosts file" do
-        expected_command = "ssh-keyscan -p22 -H example.com >> ~/.ssh/known_hosts 2>/dev/null"
-        expect(ssh_provisioner).to receive(:system).with(expected_command)
-
-        ssh_provisioner.send(:add_ssh_known_host!, provision_ssh_uri)
-      end
-    end
-
-    describe "#password_auth_enabled?" do
-      it "returns true when password authentication is enabled" do
-        expect(provision_server).to receive(:run!).with(
-          %q{grep -E '^\s*PasswordAuthentication\s+yes' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || true},
-          home: true,
-          capture: true
-        ).and_return("PasswordAuthentication yes\n")
-
-        expect(ssh_provisioner.send(:password_auth_enabled?)).to be true
-      end
-
-      it "returns false when password authentication is disabled" do
-        expect(provision_server).to receive(:run!).with(
-          %q{grep -E '^\s*PasswordAuthentication\s+yes' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || true},
-          home: true,
-          capture: true
-        ).and_return("")
-
-        expect(ssh_provisioner.send(:password_auth_enabled?)).to be false
-      end
-
-      it "returns false when grep returns nil" do
-        expect(provision_server).to receive(:run!).with(
-          %q{grep -E '^\s*PasswordAuthentication\s+yes' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || true},
-          home: true,
-          capture: true
-        ).and_return(nil)
-
-        expect(ssh_provisioner.send(:password_auth_enabled?)).to be false
-      end
-    end
-
-    describe "#disable_password_auth!" do
-      it "creates sshd config file to disable password authentication and restarts ssh" do
-        expect(provision_server).to receive(:run!).with(
-          %q{echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/disable_password_auth.conf; sudo service ssh restart},
-          home: true
-        )
-
-        ssh_provisioner.send(:disable_password_auth!)
-      end
-    end
-  end
-end

data/spec/bard/provision/swapfile_spec.rb

@@ -1,32 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/swapfile"
-
-describe Bard::Provision::Swapfile do
-  let(:config) { { production: double("production") } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision_server) { double("provision_server") }
-  let(:swapfile) { Bard::Provision::Swapfile.new(config, ssh_url) }
-
-  before do
-    allow(swapfile).to receive(:provision_server).and_return(provision_server)
-    allow(swapfile).to receive(:print)
-    allow(swapfile).to receive(:puts)
-  end
-
-  describe "#call" do
-    it "sets up swapfile on the server" do
-      expect(provision_server).to receive(:run!).with(/if \[ ! -f \/swapfile \]/)
-
-      swapfile.call
-    end
-
-    it "prints status messages" do
-      allow(provision_server).to receive(:run!)
-      expect(swapfile).to receive(:print).with("Swapfile:")
-      expect(swapfile).to receive(:puts).with(" ✓")
-
-      swapfile.call
-    end
-  end
-end

data/spec/bard/provision/user_spec.rb

@@ -1,103 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-require "bard/provision/user"
-
-describe Bard::Provision::User do
-  let(:old_ssh_uri) { double("old_ssh_uri", user: "root", host: "example.com", port: 22) }
-  let(:new_ssh_uri) { double("new_ssh_uri", user: "deploy", host: "example.com", port: 22) }
-  let(:server) { double("server", ssh_uri: new_ssh_uri) }
-  let(:config) { { production: server } }
-  let(:ssh_url) { "root@example.com" }
-  let(:provision_server) { double("provision_server", ssh_uri: old_ssh_uri) }
-  let(:user_provisioner) { Bard::Provision::User.new(config, ssh_url) }
-
-  before do
-    allow(user_provisioner).to receive(:server).and_return(server)
-    allow(user_provisioner).to receive(:provision_server).and_return(provision_server)
-    allow(user_provisioner).to receive(:print)
-    allow(user_provisioner).to receive(:puts)
-    allow(user_provisioner).to receive(:system)
-  end
-
-  describe "#call" do
-    context "when new user already exists" do
-      it "skips user creation" do
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri, user: "deploy").and_return(true)
-
-        expect(provision_server).not_to receive(:run!)
-
-        user_provisioner.call
-      end
-    end
-
-    context "when new user doesn't exist but old user works" do
-      it "creates the new user" do
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri, user: "deploy").and_return(false)
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri).and_return(true)
-
-        expected_commands = [
-          "sudo useradd -m -s /bin/bash deploy",
-          "sudo usermod -aG sudo deploy",
-          "echo \"deploy ALL=(ALL) NOPASSWD:ALL\" | sudo tee -a /etc/sudoers",
-          "sudo mkdir -p ~deploy/.ssh",
-          "sudo cp ~/.ssh/authorized_keys ~deploy/.ssh/authorized_keys",
-          "sudo chown -R deploy:deploy ~deploy/.ssh",
-          "sudo chmod +rx ~deploy"
-        ].join("; ")
-
-        expect(provision_server).to receive(:run!).with(expected_commands, home: true)
-
-        user_provisioner.call
-      end
-
-      it "prints status messages during user creation" do
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri, user: "deploy").and_return(false)
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri).and_return(true)
-        allow(provision_server).to receive(:run!)
-
-        expect(user_provisioner).to receive(:print).with("User:")
-        expect(user_provisioner).to receive(:print).with(" Adding user deploy,")
-        expect(user_provisioner).to receive(:puts).with(" ✓")
-
-        user_provisioner.call
-      end
-    end
-
-    context "when neither old nor new user can SSH" do
-      it "raises an error" do
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri, user: "deploy").and_return(false)
-        allow(user_provisioner).to receive(:ssh_with_user?).with(old_ssh_uri).and_return(false)
-
-        expect { user_provisioner.call }.to raise_error("can't ssh in with user deploy or root")
-      end
-    end
-  end
-
-  describe "#ssh_with_user?" do
-    it "tests SSH connection with specified user" do
-      expect(user_provisioner).to receive(:system).with("ssh -o ConnectTimeout=2 -p22 deploy@example.com : >/dev/null 2>&1")
-
-      user_provisioner.send(:ssh_with_user?, old_ssh_uri, user: "deploy")
-    end
-
-    it "uses default user from SSH URI if not specified" do
-      expect(user_provisioner).to receive(:system).with("ssh -o ConnectTimeout=2 -p22 root@example.com : >/dev/null 2>&1")
-
-      user_provisioner.send(:ssh_with_user?, old_ssh_uri)
-    end
-  end
-
-  describe "private methods" do
-    describe "#new_user" do
-      it "returns the target user from server SSH URI" do
-        expect(user_provisioner.send(:new_user)).to eq("deploy")
-      end
-    end
-
-    describe "#old_user" do
-      it "returns the current user from provision server SSH URI" do
-        expect(user_provisioner.send(:old_user)).to eq("root")
-      end
-    end
-  end
-end

data/spec/bard/provision_spec.rb

@@ -1,28 +0,0 @@
-require "spec_helper"
-require "bard/provision"
-
-describe Bard::Provision do
-  let(:config) { { production: double("production", key: :production) } }
-  let(:ssh_url) { "user@example.com" }
-  let(:provision) { Bard::Provision.new(config, ssh_url) }
-
-  describe ".call" do
-    it "creates a new instance and calls it" do
-      expect_any_instance_of(Bard::Provision).to receive(:call)
-      Bard::Provision.call(config, ssh_url)
-    end
-  end
-
-  describe "#server" do
-    it "returns the production server from config" do
-      expect(provision.send(:server)).to eq(config[:production])
-    end
-  end
-
-  describe "#provision_server" do
-    it "returns server with ssh_url" do
-      expect(config[:production]).to receive(:with).with(ssh: ssh_url)
-      provision.send(:provision_server)
-    end
-  end
-end

data/spec/bard/server_spec.rb

@@ -1,127 +0,0 @@
-require "bard/server"
-
-describe Bard::Server do
-  subject do
-    described_class.define("tracker", :production) do
-      ssh "www@tracker.botandrose.com:22022"
-      path "work/tracker"
-      ping "tracker.botandrose.com", "www.tracker.botandrose.com"
-      gateway "www@staging.botandrose.com:22022"
-      ssh_key "~/.ssh/id_rsa.pub"
-      env "RAILS_ENV=production"
-    end
-  end
-
-  describe "#ssh" do
-    it "returns the ssh setting" do
-      expect(subject.ssh).to eq "www@tracker.botandrose.com:22022"
-    end
-  end
-
-  describe "#ssh_uri" do
-    it "exposes the host" do
-      expect(subject.ssh_uri.host).to eq "tracker.botandrose.com"
-    end
-
-    it "exposes the user" do
-      expect(subject.ssh_uri.user).to eq "www"
-    end
-
-    it "exposes the port" do
-      expect(subject.ssh_uri.port).to eq 22022
-    end
-
-    it "has no path" do
-      expect(subject.ssh_uri.path).to be_empty
-    end
-
-    it "can specify another field to read from" do
-      expect(subject.ssh_uri(:gateway).host).to eq "staging.botandrose.com"
-    end
-
-    it "has no path" do
-      expect(subject.ssh_uri.path).to be_empty
-    end
-  end
-
-  describe "#scp_uri" do
-    it "exposes the host" do
-      expect(subject.scp_uri.host).to eq "tracker.botandrose.com"
-    end
-
-    it "exposes the user" do
-      expect(subject.scp_uri.user).to eq "www"
-    end
-
-    it "exposes the port" do
-      expect(subject.scp_uri.port).to eq 22022
-    end
-
-    it "includes the path to the project" do
-      expect(subject.scp_uri.path).to eq "/work/tracker"
-    end
-
-    it "compiles to an scp:// string" do
-      expect(subject.scp_uri.to_s).to eq "scp://www@tracker.botandrose.com:22022/work/tracker"
-    end
-  end
-
-  describe "#rsync_uri" do
-    it "works" do
-      expect(subject.rsync_uri("public/assets")).to eq "www@tracker.botandrose.com:work/tracker/public/assets"
-    end
-  end
-
-  describe "#path" do
-    it "returns the path setting" do
-      expect(subject.path).to eq "work/tracker"
-    end
-
-    it "defaults to the project name" do
-      subject.path nil
-      expect(subject.path).to eq "tracker"
-    end
-  end
-
-  describe "#ping" do
-    it "returns the ping urls, normalized" do
-      expect(subject.ping).to eq [
-        "https://tracker.botandrose.com",
-        "https://www.tracker.botandrose.com",
-      ]
-    end
-
-    it "accepts paths" do
-      subject.ping "/ping"
-      expect(subject.ping).to eq ["https://tracker.botandrose.com/ping"]
-    end
-
-    it "defaults to the ssh value" do
-      subject.ping nil
-      expect(subject.ping).to eq ["https://tracker.botandrose.com"]
-    end
-
-    it "accepts false to disable pings" do
-      subject.ping false
-      expect(subject.ping).to eq []
-    end
-  end
-
-  describe "#gateway" do
-    it "returns the gateway setting" do
-      expect(subject.gateway).to eq "www@staging.botandrose.com:22022"
-    end
-  end
-
-  describe "#ssh_key" do
-    it "returns the ssh_key setting" do
-      expect(subject.ssh_key).to eq "~/.ssh/id_rsa.pub"
-    end
-  end
-
-  describe "#env" do
-    it "returns the env setting" do
-      expect(subject.env).to eq "RAILS_ENV=production"
-    end
-  end
-end