bard 1.4.8 → 1.4.9

data/spec/bard/cli/master_key_spec.rb

@@ -0,0 +1,52 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/master_key"
+require "thor"
+
+class TestMasterKeyCLI < Thor
+  include Bard::CLI::MasterKey
+
+  attr_reader :config, :options
+
+  def initialize
+    super
+    @config = {}
+    @options = {}
+  end
+end
+
+describe Bard::CLI::MasterKey do
+  let(:from_server) { double("production") }
+  let(:to_server) { double("local") }
+  let(:config) { { production: from_server, local: to_server } }
+  let(:cli) { TestMasterKeyCLI.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(from_server).to receive(:copy_file).with("config/master.key", 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(staging_server).to receive(:copy_file).with("config/master.key", to: to_server)
+
+      cli.master_key
+    end
+  end
+end

data/spec/bard/cli/new_spec.rb

@@ -0,0 +1,60 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/new"
+
+describe Bard::CLI::New do
+  let(:new_cli) { Bard::CLI::New.new(double("cli")) }
+
+  before do
+    allow(new_cli).to receive(:puts)
+    allow(new_cli).to receive(:exit)
+    allow(new_cli).to receive(:run!)
+    allow(new_cli).to receive(:green).and_return("")
+    allow(new_cli).to receive(:red).and_return("")
+    allow(new_cli).to receive(:yellow).and_return("")
+    allow(File).to receive(:read).and_return("master_key_content")
+  end
+
+  describe "#new" do
+    context "with invalid project name" do
+      before do
+        allow(new_cli).to receive(:create_project)
+        allow(new_cli).to receive(:push_to_github)
+        allow(new_cli).to receive(:stage)
+      end
+
+      it "should reject names starting with uppercase" do
+        expect(new_cli).to receive(:puts).with(/Invalid project name/)
+        expect(new_cli).to receive(:exit).with(1)
+
+        new_cli.new("InvalidProject")
+      end
+
+      it "should reject names with special characters" do
+        expect(new_cli).to receive(:puts).with(/Invalid project name/)
+        expect(new_cli).to receive(:exit).with(1)
+
+        new_cli.new("invalid-project")
+      end
+
+      it "should reject names starting with numbers" do
+        expect(new_cli).to receive(:puts).with(/Invalid project name/)
+        expect(new_cli).to receive(:exit).with(1)
+
+        new_cli.new("1invalidproject")
+      end
+    end
+  end
+
+  describe "#ruby_version" do
+    it "returns the ruby version" do
+      expect(new_cli.send(:ruby_version)).to eq("ruby-3.4.2")
+    end
+  end
+
+  describe "#template_path" do
+    it "returns the path to the rails template" do
+      expect(new_cli.send(:template_path)).to match(/new_rails_template\.rb$/)
+    end
+  end
+end

data/spec/bard/cli/open_spec.rb

@@ -0,0 +1,67 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/open"
+require "thor"
+
+class TestOpenCLI < Thor
+  include Bard::CLI::Open
+
+  attr_reader :config
+
+  def initialize
+    super
+    @config = {}
+  end
+
+  def project_name
+    "test_project"
+  end
+end
+
+describe Bard::CLI::Open do
+  let(:server) { double("server", ping: ["https://example.com"]) }
+  let(:config) { { production: server } }
+  let(:cli) { TestOpenCLI.new }
+
+  before do
+    allow(cli).to receive(:config).and_return(config)
+    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 server URL by default" do
+      expect(cli).to receive(:exec).with("xdg-open https://example.com")
+
+      cli.open
+    end
+
+    it "should open specified server URL" do
+      staging_server = double("staging", ping: ["https://staging.example.com"])
+      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 server 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 server" do
+      expect(cli.send(:open_url, :ci)).to eq("https://github.com/botandrosedesign/test_project/actions/workflows/ci.yml")
+    end
+
+    it "returns server ping URL for other servers" do
+      expect(cli.send(:open_url, :production)).to eq("https://example.com")
+    end
+  end
+end

data/spec/bard/cli/ping_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/ping"
+require "thor"
+
+class TestPingCLI < Thor
+  include Bard::CLI::Ping
+
+  attr_reader :config
+
+  def initialize
+    super
+    @config = {}
+  end
+end
+
+describe Bard::CLI::Ping do
+  let(:server) { double("server", ping: ["https://example.com"]) }
+  let(:config) { { production: server } }
+  let(:cli) { TestPingCLI.new }
+
+  before do
+    allow(cli).to receive(:config).and_return(config)
+    allow(cli).to receive(:puts)
+    allow(cli).to receive(:exit)
+  end
+
+  describe "#ping" do
+    it "should have a ping command" do
+      expect(cli).to respond_to(:ping)
+    end
+
+    it "should call Bard::Ping with the server" do
+      expect(Bard::Ping).to receive(:call).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/provision_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/provision"
+
+describe Bard::CLI::Provision do
+  let(:config) { { production: double("production", ssh: "user@example.com") } }
+  let(:provision_cli) { Bard::CLI::Provision.new(double("cli")) }
+
+  before do
+    allow(provision_cli).to receive(:config).and_return(config)
+    allow(provision_cli).to receive(:options).and_return({ steps: ["SSH", "User"] })
+  end
+
+  describe "STEPS constant" do
+    it "defines the provisioning steps" do
+      expect(Bard::CLI::Provision::STEPS).to include("SSH", "User", "Apt", "MySQL", "Deploy")
+      expect(Bard::CLI::Provision::STEPS).to be_a(Array)
+    end
+  end
+
+  describe "#provision" do
+    it "should run provision steps" do
+      expect(Bard::Provision).to receive(:const_get).with("SSH").and_return(double("ssh_step", call: true))
+      expect(Bard::Provision).to receive(:const_get).with("User").and_return(double("user_step", call: true))
+
+      provision_cli.provision
+    end
+
+    it "should use production ssh by default" do
+      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
+
+      provision_cli.provision
+    end
+
+    it "should accept custom ssh_url" do
+      custom_ssh = "root@newserver.com"
+      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
+
+      provision_cli.provision(custom_ssh)
+    end
+  end
+end

data/spec/bard/cli/run_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/run"
+require "thor"
+
+class TestRunCLI < Thor
+  include Bard::CLI::Run
+
+  attr_reader :config
+
+  def initialize
+    super
+    @config = {}
+  end
+end
+
+describe Bard::CLI::Run do
+  let(:server) { double("server") }
+  let(:config) { { production: server } }
+  let(:cli) { TestRunCLI.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("")
+  end
+
+  describe "#run" do
+    it "should have a run command" do
+      expect(cli).to respond_to(:run)
+    end
+
+    it "should run command on production server" do
+      expect(server).to receive(:run!).with("ls -la", verbose: true)
+
+      cli.run("ls", "-la")
+    end
+
+    it "should handle command errors" do
+      error = Bard::Command::Error.new("Command failed")
+      allow(server).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

@@ -0,0 +1,76 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/setup"
+require "thor"
+
+class TestSetupCLI < Thor
+  include Bard::CLI::Setup
+
+  attr_reader :config
+
+  def initialize
+    super
+    @config = {}
+  end
+
+  def project_name
+    "test_project"
+  end
+end
+
+describe Bard::CLI::Setup do
+  let(:cli) { TestSetupCLI.new }
+
+  before do
+    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
+    it "should have a setup command" do
+      expect(cli).to respond_to(:setup)
+    end
+
+    it "should create nginx common config" do
+      expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/snippets\/common\.conf/)
+      expect(cli).to receive(:system).with(/sudo tee \/etc\/nginx\/sites-available\/test_project/)
+      expect(cli).to receive(:system).with(/sudo ln -sf/)
+      expect(cli).to receive(:system).with("sudo service nginx restart")
+
+      cli.setup
+    end
+  end
+
+  describe "#nginx_server_name" do
+    let(:production_server) { double("production", ping: ["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.send(: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.send(: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.send(:nginx_server_name)).to eq("test_project.localhost")
+      end
+    end
+  end
+end

data/spec/bard/cli/ssh_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/ssh"
+require "thor"
+
+class TestSSHCLI < Thor
+  include Bard::CLI::SSH
+
+  attr_reader :config, :options
+
+  def initialize
+    super
+    @config = {}
+    @options = {}
+  end
+end
+
+describe Bard::CLI::SSH do
+  let(:server) { double("server") }
+  let(:config) { { production: server } }
+  let(:cli) { TestSSHCLI.new }
+
+  before do
+    allow(cli).to receive(:config).and_return(config)
+  end
+
+  describe "#ssh" do
+    it "should have an ssh command" do
+      expect(cli).to respond_to(:ssh)
+    end
+
+    it "should execute shell on production server by default" do
+      allow(cli).to receive(:options).and_return({ home: false })
+      expect(server).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(server).to receive(:exec!).with("exec $SHELL -l", home: true)
+
+      cli.ssh
+    end
+
+    it "should connect to specified server" do
+      staging_server = double("staging")
+      allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+      allow(cli).to receive(:options).and_return({ home: false })
+      expect(staging_server).to receive(:exec!).with("exec $SHELL -l", home: false)
+
+      cli.ssh(:staging)
+    end
+  end
+end

data/spec/bard/cli/stage_spec.rb

@@ -0,0 +1,77 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/stage"
+require "thor"
+
+class TestStageCLI < Thor
+  include Bard::CLI::Stage
+
+  attr_reader :config
+
+  def initialize
+    super
+    @config = nil
+  end
+end
+
+describe Bard::CLI::Stage do
+  let(:staging_server) { double("staging") }
+  let(:servers) { { production: double("production"), staging: staging_server } }
+  let(:config) { double("config", servers: servers) }
+  let(:cli) { TestStageCLI.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(:run!)
+    allow(cli).to receive(:ping)
+    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("main")
+    allow(config).to receive(:[]).with(:staging).and_return(staging_server)
+  end
+
+  describe "#stage" do
+    it "should have a stage command" do
+      expect(cli).to respond_to(:stage)
+    end
+
+    context "when production server is defined" do
+      it "pushes branch and stages it" do
+        expect(cli).to receive(:run!).with("git push -u origin main", verbose: true)
+        expect(staging_server).to receive(:run!).with("git fetch && git checkout -f origin/main && bin/setup")
+        expect(cli).to receive(:ping).with(:staging)
+
+        cli.stage
+      end
+
+      it "accepts custom branch" do
+        expect(cli).to receive(:run!).with("git push -u origin develop", verbose: true)
+        expect(staging_server).to receive(:run!).with("git fetch && git checkout -f origin/develop && bin/setup")
+
+        cli.stage("develop")
+      end
+    end
+
+    context "when production server is not defined" do
+      let(:servers) { { staging: staging_server } }
+
+      it "raises an error" do
+        expect { cli.stage }.to raise_error(Thor::Error, /bard stage.*is disabled/)
+      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.stage
+      end
+    end
+  end
+end

data/spec/bard/cli/vim_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+require "bard/cli"
+require "bard/cli/vim"
+require "thor"
+
+class TestVimCLI < Thor
+  include Bard::CLI::Vim
+end
+
+describe Bard::CLI::Vim do
+  let(:cli) { TestVimCLI.new }
+
+  before do
+    allow(cli).to receive(:exec)
+  end
+
+  describe "#vim" do
+    it "should have a vim command" do
+      expect(cli).to respond_to(:vim)
+    end
+
+    it "should exec vim with git diff files by default" do
+      expect(cli).to receive(:exec).with("vim -p `git diff master --name-only | grep -v sass$ | tac`")
+
+      cli.vim
+    end
+
+    it "should exec vim with specified branch" do
+      expect(cli).to receive(:exec).with("vim -p `git diff develop --name-only | grep -v sass$ | tac`")
+
+      cli.vim("develop")
+    end
+  end
+end

data/spec/bard/command_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+require "bard/command"
+
+describe Bard::Command do
+  let(:remote) { double("remote", to_sym: :remote, ssh: true, env: nil, path: "/path/to", ssh_key: nil, ssh_uri: "user@example.com", gateway: nil) }
+
+  describe ".run" do
+    it "should run a command locally" do
+      expect(Open3).to receive(:capture3).with("ls -l").and_return(["output", "", 0])
+      Bard::Command.run "ls -l"
+    end
+
+    it "should run a command on a remote server" do
+      expect(Open3).to receive(:capture3).with("ssh -tt  user@example.com 'cd /path/to && ls -l'").and_return(["output", "", 0])
+      Bard::Command.run "ls -l", on: remote
+    end
+  end
+
+  describe ".run!" do
+    it "should run a command locally" do
+      expect(Open3).to receive(:capture3).with("ls -l").and_return(["output", "", 0])
+      Bard::Command.run! "ls -l"
+    end
+
+    it "should raise an error if the command fails" do
+      expect(Open3).to receive(:capture3).with("ls -l").and_return(["output", "error", 1])
+      expect { Bard::Command.run! "ls -l" }.to raise_error(Bard::Command::Error)
+    end
+  end
+
+  describe ".exec!" do
+    it "should exec a command locally" do
+      expect_any_instance_of(Bard::Command).to receive(:exec).with("ls -l")
+      Bard::Command.exec! "ls -l"
+    end
+  end
+end

data/spec/bard/copy_spec.rb

@@ -0,0 +1,33 @@
+require "spec_helper"
+require "bard/copy"
+
+describe Bard::Copy do
+  let(:production) { double("production", key: :production, scp_uri: "user@example.com:/path/to/file", rsync_uri: "user@example.com:/path/to/", gateway: nil, ssh_key: nil, path: "/path/to") }
+  let(:local) { double("local", key: :local) }
+
+  context ".file" do
+    it "should copy a file from a remote server to the local machine" do
+      expect(Bard::Command).to receive(:run!).with("scp   user@example.com:/path/to/file path/to/file", verbose: false)
+      Bard::Copy.file "path/to/file", from: production, to: local
+    end
+
+    it "should copy a file from the local machine to a remote server" do
+      expect(Bard::Command).to receive(:run!).with("scp   path/to/file user@example.com:/path/to/file", verbose: false)
+      Bard::Copy.file "path/to/file", from: local, to: production
+    end
+  end
+
+  context ".dir" do
+    it "should copy a directory from a remote server to the local machine" do
+      allow(production).to receive_message_chain("ssh_uri.port").and_return(22)
+      expect(Bard::Command).to receive(:run!).with("rsync -e'ssh  -p22' --delete --info=progress2 -az user@example.com:/path/to/ ./path/", verbose: false)
+      Bard::Copy.dir "path/to", from: production, to: local
+    end
+
+    it "should copy a directory from the local machine to a remote server" do
+      allow(production).to receive_message_chain("ssh_uri.port").and_return(22)
+      expect(Bard::Command).to receive(:run!).with("rsync -e'ssh  -p22' --delete --info=progress2 -az ./path/to user@example.com:/path/to/", verbose: false)
+      Bard::Copy.dir "path/to", from: local, to: production
+    end
+  end
+end