bard 2.0.0.beta → 2.0.0

data/spec/bard/github_pages_spec.rb

@@ -1,143 +0,0 @@
-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 "#build_site" do
-    it "uses the locked port" do
-      github_pages.instance_variable_set(:@sha, "abc123")
-      github_pages.instance_variable_set(:@build_dir, "tmp/github-build-abc123")
-      github_pages.instance_variable_set(:@domain, "example.com")
-
-      allow(github_pages).to receive(:with_locked_port).and_yield(3005)
-
-      expect(github_pages).to receive(:run!).with(satisfy { |cmd|
-        cmd.include?("rails s -p 3005") && cmd.include?("http://localhost:3005")
-      }).ordered
-
-      expect(github_pages).to receive(:run!).with(include("kill")).ordered
-
-      github_pages.send(:build_site)
-    end
-  end
-
-  describe "#with_locked_port" do
-    let(:file_mock) { double("file", close: true) }
-
-    before do
-      allow(File).to receive(:open).and_return(file_mock)
-    end
-
-    it "yields the first available port" do
-      allow(file_mock).to receive(:flock).and_return(true)
-      
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything)
-      
-      yielded_port = nil
-      github_pages.send(:with_locked_port) { |p| yielded_port = p }
-      expect(yielded_port).to eq(3000)
-    end
-
-    it "retries if the first port is locked" do
-      # 1. Try port 3000
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3000.lock", anything, anything).ordered
-      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(false).ordered
-      expect(file_mock).to receive(:close).ordered
-
-      # 2. Try port 3001
-      expect(File).to receive(:open).with("/tmp/bard_github_pages_3001.lock", anything, anything).ordered
-      expect(file_mock).to receive(:flock).with(File::LOCK_EX | File::LOCK_NB).and_return(true).ordered
-      
-      # 3. Cleanup after yielding
-      expect(file_mock).to receive(:flock).with(File::LOCK_UN).ordered
-      expect(file_mock).to receive(:close).ordered
-
-      yielded_port = nil
-      github_pages.send(:with_locked_port) { |p| yielded_port = p }
-      expect(yielded_port).to eq(3001)
-    end
-
-    it "raises an error if no ports are available" do
-      allow(file_mock).to receive(:flock).and_return(false)
-      
-      expect {
-        github_pages.send(:with_locked_port) {}
-      }.to raise_error(/Could not find an available port/)
-    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/provision/app_spec.rb

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

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

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

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

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

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

@@ -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