bard 1.7.3 → 1.8.0.beta

data/spec/bard/deprecation_spec.rb

@@ -0,0 +1,202 @@
+require "bard/deprecation"
+require "bard/config"
+require "bard/server"
+
+describe Bard::Deprecation do
+  before do
+    Bard::Deprecation.reset!
+  end
+
+  describe ".warn" do
+    it "outputs a deprecation warning to stderr" do
+      expect {
+        Bard::Deprecation.warn "test message"
+      }.to output(/\[DEPRECATION\] test message/).to_stderr
+    end
+
+    it "includes the callsite location" do
+      output = capture_stderr { Bard::Deprecation.warn "test message" }
+      expect(output).to match(/called from.*deprecation_spec\.rb/)
+    end
+
+    it "only warns once per callsite" do
+      output = capture_stderr do
+        3.times { Bard::Deprecation.warn "repeated message" }
+      end
+      expect(output.scan(/\[DEPRECATION\]/).count).to eq 1
+    end
+
+    it "warns separately for different callsites" do
+      output = capture_stderr do
+        Bard::Deprecation.warn "message 1"
+        Bard::Deprecation.warn "message 2"
+      end
+      expect(output.scan(/\[DEPRECATION\]/).count).to eq 2
+    end
+  end
+
+  describe ".reset!" do
+    it "clears the warning cache" do
+      capture_stderr { Bard::Deprecation.warn "test" }
+      Bard::Deprecation.reset!
+      output = capture_stderr { Bard::Deprecation.warn "test" }
+      expect(output).to include("[DEPRECATION]")
+    end
+  end
+
+  def capture_stderr
+    original_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = original_stderr
+  end
+end
+
+describe "Deprecation warnings" do
+  before do
+    Bard::Deprecation.reset!
+  end
+
+  def capture_stderr
+    original_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = original_stderr
+  end
+
+  describe "Config#server" do
+    it "warns when using server instead of target" do
+      output = capture_stderr do
+        Bard::Config.new("test", source: <<~SOURCE)
+          server :production do
+            ssh "user@host:22"
+          end
+        SOURCE
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("`server` is deprecated")
+      expect(output).to include("use `target` instead")
+    end
+
+    it "does not warn when using target" do
+      output = capture_stderr do
+        Bard::Config.new("test", source: <<~SOURCE)
+          target :production do
+            ssh "user@host:22"
+          end
+        SOURCE
+      end
+      expect(output).not_to include("[DEPRECATION]")
+    end
+  end
+
+  describe "Server SSH options" do
+    it "warns when using separate path method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          path "/app"
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("Separate SSH options are deprecated")
+    end
+
+    it "warns when using separate gateway method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          gateway "bastion@host:22"
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("Separate SSH options are deprecated")
+    end
+
+    it "warns when using separate ssh_key method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          ssh_key "~/.ssh/id_rsa"
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("Separate SSH options are deprecated")
+    end
+
+    it "warns when using separate env method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          env "RAILS_ENV=production"
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("Separate SSH options are deprecated")
+    end
+  end
+
+  describe "Server strategy configuration" do
+    it "warns when using strategy method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          strategy :custom
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("`strategy` is deprecated")
+    end
+
+    it "warns when using option method" do
+      output = capture_stderr do
+        Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          option :run_tests, true
+        end
+      end
+      expect(output).to include("[DEPRECATION]")
+      expect(output).to include("`option` is deprecated")
+    end
+
+    it "stores strategy name for backward compatibility" do
+      server = nil
+      capture_stderr do
+        server = Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          strategy :jets
+        end
+      end
+      expect(server.strategy_name).to eq :jets
+    end
+
+    it "stores strategy options for backward compatibility" do
+      server = nil
+      capture_stderr do
+        server = Bard::Server.define("test", :production) do
+          ssh "user@host:22"
+          option :run_tests, true
+          option :verbose, false
+        end
+      end
+      expect(server.strategy_options).to eq({ run_tests: true, verbose: false })
+    end
+  end
+
+  describe "Target (new API)" do
+    it "does not warn when using hash options with ssh" do
+      output = capture_stderr do
+        Bard::Config.new("test", source: <<~SOURCE)
+          target :production do
+            ssh "user@host:22", path: "/app", gateway: "bastion@host:22"
+          end
+        SOURCE
+      end
+      expect(output).not_to include("[DEPRECATION]")
+    end
+  end
+end

data/spec/bard/dynamic_dsl_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+require "bard/target"
+require "bard/deploy_strategy"
+
+describe "Dynamic DSL Methods" do
+  let(:config) { double("config", project_name: "testapp") }
+  let(:target) { Bard::Target.new(:production, config) }
+
+  before do
+    # Register test strategies
+    class Bard::DeployStrategy::Jets < Bard::DeployStrategy
+      def deploy
+        # test implementation
+      end
+    end
+
+    class Bard::DeployStrategy::Docker < Bard::DeployStrategy
+      def deploy
+        # test implementation
+      end
+    end
+  end
+
+  describe "method_missing for strategies" do
+    it "enables strategy when method name matches registered strategy" do
+      target.jets("https://api.example.com")
+      expect(target.deploy_strategy).to eq(:jets)
+    end
+
+    it "stores strategy options" do
+      target.jets("https://api.example.com", run_tests: true, env: "production")
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options[:env]).to eq("production")
+    end
+
+    it "auto-configures ping URL from first argument if it's a URL" do
+      target.jets("https://api.example.com")
+      expect(target.ping_urls).to include("https://api.example.com")
+    end
+
+    it "works with multiple strategies" do
+      target1 = Bard::Target.new(:production, config)
+      target2 = Bard::Target.new(:staging, config)
+
+      target1.jets("https://api.example.com")
+      target2.docker("https://app.example.com")
+
+      expect(target1.deploy_strategy).to eq(:jets)
+      expect(target2.deploy_strategy).to eq(:docker)
+    end
+
+    it "raises NoMethodError for unknown methods" do
+      expect { target.unknown_method("arg") }
+        .to raise_error(NoMethodError)
+    end
+  end
+
+  describe "strategy DSL integration" do
+    it "allows chaining with other configuration methods" do
+      target.jets("https://api.example.com", run_tests: true)
+      target.ssh("deploy@example.com:22", path: "app")
+
+      expect(target.deploy_strategy).to eq(:jets)
+      expect(target.has_capability?(:ssh)).to be true
+    end
+
+    it "allows strategy configuration without ping URL" do
+      target.docker(skip_build: true)
+      options = target.strategy_options(:docker)
+      expect(options[:skip_build]).to be true
+    end
+  end
+
+  describe "#strategy_options" do
+    it "returns options for the specified strategy" do
+      target.jets("https://api.example.com", run_tests: true, env: "prod")
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options[:env]).to eq("prod")
+    end
+
+    it "returns empty hash if strategy not configured" do
+      options = target.strategy_options(:unknown)
+      expect(options).to eq({})
+    end
+
+    it "filters out URL from options" do
+      target.jets("https://api.example.com", run_tests: true)
+      options = target.strategy_options(:jets)
+      expect(options[:run_tests]).to be true
+      expect(options).not_to have_key(:url)
+    end
+  end
+
+  describe "#deploy_strategy" do
+    it "returns the configured strategy symbol" do
+      target.jets("https://api.example.com")
+      expect(target.deploy_strategy).to eq(:jets)
+    end
+
+    it "returns nil if no strategy configured" do
+      expect(target.deploy_strategy).to be_nil
+    end
+  end
+
+  describe "#deploy_strategy_instance" do
+    it "creates an instance of the strategy class" do
+      target.jets("https://api.example.com")
+      instance = target.deploy_strategy_instance
+      expect(instance).to be_a(Bard::DeployStrategy::Jets)
+      expect(instance.target).to eq(target)
+    end
+
+    it "raises error if no strategy configured" do
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/No deployment strategy configured/)
+    end
+
+    it "raises error if strategy class not found" do
+      target.instance_variable_set(:@deploy_strategy, :unknown)
+      expect { target.deploy_strategy_instance }
+        .to raise_error(/Unknown deployment strategy: unknown/)
+    end
+  end
+end

data/spec/bard/github_pages_spec.rb

@@ -38,6 +38,69 @@ describe Bard::GithubPages do
     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")
@@ -77,4 +140,4 @@ describe Bard::GithubPages do
       end
     end
   end
-end
+end

data/spec/bard/ssh_server_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+require "bard/ssh_server"
+
+describe Bard::SSHServer do
+  describe "#initialize" do
+    it "parses SSH URI with user, host, and port" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.user).to eq("deploy")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+    end
+
+    it "handles SSH URI without port (defaults to 22)" do
+      server = described_class.new("deploy@example.com")
+      expect(server.user).to eq("deploy")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+    end
+
+    it "handles SSH URI without user (uses current user)" do
+      server = described_class.new("example.com:22")
+      expect(server.host).to eq("example.com")
+      expect(server.port).to eq("22")
+      expect(server.user).to eq(ENV['USER'])
+    end
+
+    it "accepts options hash" do
+      server = described_class.new("deploy@example.com:22",
+        path: "/app",
+        gateway: "bastion@example.com:22",
+        ssh_key: "/path/to/key",
+        env: "RAILS_ENV=production"
+      )
+
+      expect(server.path).to eq("/app")
+      expect(server.gateway).to eq("bastion@example.com:22")
+      expect(server.ssh_key).to eq("/path/to/key")
+      expect(server.env).to eq("RAILS_ENV=production")
+    end
+  end
+
+  describe "#ssh_uri" do
+    it "returns the SSH connection string" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.ssh_uri).to eq("deploy@example.com:22")
+    end
+
+    it "includes port if non-standard" do
+      server = described_class.new("deploy@example.com:2222")
+      expect(server.ssh_uri).to eq("deploy@example.com:2222")
+    end
+  end
+
+  describe "#hostname" do
+    it "extracts hostname from SSH URI" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.hostname).to eq("example.com")
+    end
+
+    it "handles IP addresses" do
+      server = described_class.new("deploy@192.168.1.1:22")
+      expect(server.hostname).to eq("192.168.1.1")
+    end
+  end
+
+  describe "#connection_string" do
+    it "builds SSH connection string" do
+      server = described_class.new("deploy@example.com:22")
+      expect(server.connection_string).to eq("deploy@example.com")
+    end
+  end
+
+  describe "#run" do
+    let(:server) do
+      described_class.new("deploy@example.com:22", path: "/app")
+    end
+
+    it "executes command via SSH" do
+      expect(Open3).to receive(:capture3)
+        .with(/ssh.*deploy@example.com.*cd \/app && ls/)
+        .and_return(["output", "", 0])
+
+      server.run("ls")
+    end
+
+    it "includes environment variables if configured" do
+      server_with_env = described_class.new("deploy@example.com:22",
+        path: "/app",
+        env: "RAILS_ENV=production"
+      )
+
+      expect(Open3).to receive(:capture3)
+        .with(/RAILS_ENV=production/)
+        .and_return(["output", "", 0])
+
+      server_with_env.run("ls")
+    end
+  end
+
+  describe "#run!" do
+    let(:server) do
+      described_class.new("deploy@example.com:22", path: "/app")
+    end
+
+    it "executes command via SSH" do
+      expect(Open3).to receive(:capture3)
+        .with(/ssh.*deploy@example.com.*cd \/app && ls/)
+        .and_return(["output", "", 0])
+
+      server.run!("ls")
+    end
+
+    it "raises error if command fails" do
+      expect(Open3).to receive(:capture3)
+        .and_return(["", "error", 1])
+
+      expect { server.run!("false") }.to raise_error(Bard::Command::Error)
+    end
+  end
+
+  describe "#exec!" do
+    let(:server) do
+      described_class.new("deploy@example.com:22", path: "/app")
+    end
+
+    it "replaces current process with SSH command" do
+      expect(server).to receive(:exec)
+        .with(/ssh.*deploy@example.com.*cd \/app && ls/)
+
+      server.exec!("ls")
+    end
+  end
+
+  describe "path handling" do
+    it "uses path in commands if configured" do
+      server = described_class.new("deploy@example.com:22", path: "/var/www/app")
+
+      expect(Open3).to receive(:capture3)
+        .with(/cd \/var\/www\/app && ls/)
+        .and_return(["output", "", 0])
+
+      server.run("ls")
+    end
+
+    it "works without path" do
+      server = described_class.new("deploy@example.com:22")
+
+      expect(Open3).to receive(:capture3)
+        .with(/ssh.*ls/)
+        .and_return(["output", "", 0])
+
+      server.run("ls")
+    end
+  end
+
+  describe "gateway/bastion support" do
+    it "uses ProxyJump for gateway" do
+      server = described_class.new("deploy@private.example.com:22",
+        gateway: "bastion@public.example.com:22"
+      )
+
+      expect(Open3).to receive(:capture3)
+        .with(/-o ProxyJump=bastion@public.example.com:22/)
+        .and_return(["output", "", 0])
+
+      server.run("ls")
+    end
+  end
+end