bard 1.8.0.beta → 1.8.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7dba2b99b2c7cca5260a12fbcc3997a94d87daf3f2bc0f1f35c00e4c0aee34cd
-  data.tar.gz: f5353f6f79ef58a832138343f15861a2e87e6f673d982f8cdf5382746605f55a
+  metadata.gz: 115799c766998efdc0b5dba97ed4f3135fe77a2d30b67248db1a52f28915b126
+  data.tar.gz: 6eb18a8ddc93efffd1de4da94270766f50883bb2bb2cee91cf50c02cb624ca9d
 SHA512:
-  metadata.gz: 447acd705e5cf75e4fcd90c3858b81e00d574679bcc852e669d45969641c247e1d0c585f0ba003d54858154a562faec9aa79686ede914a8488be8f469e3db0ee
-  data.tar.gz: 3788ade587968dfe3d72499f19c566cfddb70e736d4ef53d25e6c65ea9019f3b0bd065d15d32f3e6a65a9470c72b262faa384a34cb8f091862438b8904d7624a
+  metadata.gz: e03e8f2f53ee3349355b4f14ae6ed238b2067350ff1159a46127738a59a5e08afcdcef2635d46536d9441cb001d4823ff074d1e39a03c291581f664c7b56eb05
+  data.tar.gz: 67d2d63759fc54b8e68216f3149ca5f936111f9fad72acec45423d396027568778e1c4817240d4c0613869ed8832306f2bbff8fa2cfc7359f357920dac0a6ef5

data/.github/workflows/ci.yml

@@ -34,5 +34,10 @@ jobs:
           done
           echo "DOCKER_HOST=tcp://127.0.0.1:8080" >> $GITHUB_ENV
 
+      - name: Build test container image
+        run: |
+          sudo podman pull ubuntu:22.04
+          sudo podman build -t bard-test-server -f spec/acceptance/docker/Dockerfile spec/acceptance/docker
+
       - name: Run tests
         run: bundle exec rake

data/Rakefile

@@ -1,7 +1,9 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
+require "cucumber/rake/task"
 
 RSpec::Core::RakeTask.new(:spec)
+Cucumber::Rake::Task.new(:cucumber)
 
-task :default => :spec
+task :default => [:spec, :cucumber]
 

data/cucumber.yml

@@ -0,0 +1 @@
+default: --publish-quiet

data/features/data.feature

@@ -0,0 +1,12 @@
+Feature: bard data
+  Copy database from a remote server to local.
+
+  Background:
+    Given a test server is running
+
+  Scenario: copies database from production to local
+    When I run: bard data
+    Then the output should contain "Dumping production database to file"
+    And the output should contain "Transfering file from production to local"
+    And the output should contain "Loading file into local database"
+    And a file "db/data.sql.gz" should exist locally

data/features/deploy.feature

@@ -0,0 +1,13 @@
+Feature: bard deploy
+  Deploy code changes to a remote server.
+
+  Background:
+    Given a test server is running
+
+  Scenario: deploys code changes to the remote server
+    Given I create a file "DEPLOYED.txt" with content "deployed by bard"
+    And I commit the changes with message "Add deployed marker"
+    When I run: bard deploy --skip-ci
+    Then the output should contain "Deploy Succeeded"
+    When I run: bard run "cat DEPLOYED.txt"
+    Then the output should contain "deployed by bard"

data/features/run.feature

@@ -0,0 +1,13 @@
+Feature: bard run
+  Execute commands on a remote server.
+
+  Background:
+    Given a test server is running
+
+  Scenario: executes a command on the remote server
+    When I run: bard run "echo hello"
+    Then the output should contain "hello"
+
+  Scenario: operates in the configured path
+    When I run: bard run "pwd"
+    Then the output should contain "testproject"

data/features/step_definitions/bard_steps.rb

@@ -0,0 +1,39 @@
+Given /^a test server is running$/ do
+  raise "Test server failed to start" unless @container && @ssh_port
+end
+
+When /^I run: bard (.+)$/ do |command|
+  run_bard(command)
+  unless @status.success?
+    raise "Command failed with status: #{@status}\nOutput: #{@stdout}"
+  end
+end
+
+When /^I run expecting failure: bard (.+)$/ do |command|
+  run_bard(command)
+  unless !@status.success?
+    raise "Command succeeded but was expected to fail\nOutput: #{@stdout}"
+  end
+end
+
+Then /^the output should contain "([^\"]+)"$/ do |expected|
+  expect(@stdout).to include(expected)
+end
+
+Given /^I create a file "([^\"]+)" with content "([^\"]+)"$/ do |filename, content|
+  Dir.chdir(@test_dir) do
+    File.write(filename, content)
+  end
+end
+
+Given /^I commit the changes with message "([^\"]+)"$/ do |message|
+  Dir.chdir(@test_dir) do
+    system("git add -A", out: File::NULL, err: File::NULL)
+    system("git commit -m '#{message}'", out: File::NULL, err: File::NULL)
+  end
+end
+
+Then /^a file "([^\"]+)" should exist locally$/ do |filename|
+  path = File.join(@test_dir, filename)
+  expect(File.exist?(path)).to be(true), "Expected file #{filename} to exist at #{path}"
+end

data/features/support/env.rb

@@ -1,47 +1,13 @@
 $LOAD_PATH.unshift(File.dirname(__FILE__) + '/../../lib')
-require 'ruby-debug'
-require 'grit'
-require 'spec/expectations'
-gem 'sqlite3-ruby'
+require 'rspec/expectations'
+require 'fileutils'
 
-ENV["PATH"] += ":#{File.dirname(File.expand_path(__FILE__))}/../../bin"
+ENV["PATH"] = "#{File.dirname(File.expand_path(__FILE__))}/../../bin:#{ENV['PATH']}"
 ENV["GIT_DIR"] = nil
 ENV["GIT_WORK_TREE"] = nil
 ENV["GIT_INDEX_FILE"] = nil
 
 ROOT = File.expand_path(File.dirname(__FILE__) + '/../..')
 
-# setup fixtures
-if File.exist?("/dev/shm")
-  FileUtils.rm_rf "tmp"
-  tmp_dir = "/dev/shm/bard_testing_tmp"
-  FileUtils.rm_rf tmp_dir
-  FileUtils.mkdir tmp_dir
-  `ln -s #{tmp_dir} tmp`
-else
-  FileUtils.rm_rf "tmp"
-  FileUtils.mkdir "tmp"
-end
-
-Dir.chdir 'tmp' do
-  `git clone --mirror --recursive #{ROOT}/fixtures/repo origin.git`
-
-  `git clone --bare --recursive origin.git submodule_a.git`
-  `git clone --bare --recursive origin.git submodule_b.git`
-  %w(development_a development_b staging production).each do |env|
-    `git clone --recursive origin.git #{env}`
-    Dir.chdir env do
-      FileUtils.cp "config/database.sample.yml", "config/database.yml"
-      `grb track master`
-      `git checkout master`
-      unless env == "production"
-        `grb track integration`
-        `git checkout integration`
-      end
-    end
-  end
-  FileUtils.mkdir "fixtures"
-  Dir.foreach "." do |file|
-    FileUtils.mv(file, "fixtures/") unless %w(fixtures . ..).include? file
-  end
-end
+# Ensure tmp directory exists
+FileUtils.mkdir_p(File.join(ROOT, "tmp"))

data/features/support/test_server.rb

@@ -0,0 +1,215 @@
+require "fileutils"
+require "open3"
+require "tmpdir"
+require "docker-api"
+
+module TestServerWorld
+  class << self
+    attr_accessor :server_available, :image_built
+  end
+
+  class PrerequisiteError < StandardError; end
+
+  def ensure_server_available
+    return if TestServerWorld.server_available
+
+    unless system("command -v podman >/dev/null 2>&1")
+      raise PrerequisiteError, "podman is not installed"
+    end
+
+    configure_container_socket
+    build_test_image
+    FileUtils.chmod(0o600, ssh_key_path)
+
+    TestServerWorld.server_available = true
+  end
+
+  def configure_container_socket
+    if ENV["DOCKER_HOST"]
+      Docker.url = ENV["DOCKER_HOST"]
+      return
+    end
+
+    socket_path = "/run/user/#{Process.uid}/podman/podman.sock"
+    unless File.exist?(socket_path)
+      system("systemctl --user start podman.socket 2>/dev/null")
+      sleep 2
+    end
+
+    unless File.exist?(socket_path)
+      raise PrerequisiteError, "Podman socket not available"
+    end
+
+    ENV["DOCKER_HOST"] = "unix://#{socket_path}"
+    Docker.url = ENV["DOCKER_HOST"]
+  end
+
+  def build_test_image
+    return if TestServerWorld.image_built
+
+    # Check if image already exists (e.g., pre-built in CI)
+    if image_exists?("bard-test-server")
+      TestServerWorld.image_built = true
+      return
+    end
+
+    system("podman pull ubuntu:22.04 >/dev/null 2>&1")
+
+    docker_dir = File.join(ROOT, "spec/acceptance/docker")
+    unless system("podman build -t bard-test-server -f #{docker_dir}/Dockerfile #{docker_dir} 2>&1")
+      raise PrerequisiteError, "Failed to build test image"
+    end
+
+    TestServerWorld.image_built = true
+  end
+
+  def image_exists?(name)
+    Docker::Image.get(name)
+    true
+  rescue Docker::Error::NotFoundError
+    false
+  end
+
+  def start_test_server
+    ensure_server_available
+
+    @container = Docker::Container.create(
+      "Image" => "localhost/bard-test-server:latest",
+      "ExposedPorts" => { "22/tcp" => {} },
+      "HostConfig" => {
+        "PortBindings" => { "22/tcp" => [{ "HostPort" => "" }] },
+        "PublishAllPorts" => true
+      }
+    )
+    @container.start
+    @container.refresh!
+
+    @ssh_port = @container.info["NetworkSettings"]["Ports"]["22/tcp"].first["HostPort"].to_i
+
+    wait_for_ssh
+    setup_test_directory
+  end
+
+  def wait_for_ssh
+    30.times do
+      return if system(
+        "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
+        "-o", "ConnectTimeout=1", "-p", @ssh_port.to_s, "-i", ssh_key_path,
+        "deploy@localhost", "true",
+        out: File::NULL, err: File::NULL
+      )
+      sleep 0.5
+    end
+    raise PrerequisiteError, "SSH not ready"
+  end
+
+  def setup_test_directory
+    # Set up git repos on the remote container
+    run_ssh "git config --global user.email 'test@example.com'"
+    run_ssh "git config --global user.name 'Test User'"
+    run_ssh "git config --global init.defaultBranch master"
+    run_ssh "mkdir -p ~/repos/testproject.git"
+    run_ssh "cd ~/repos/testproject.git && git init --bare"
+    run_ssh "git clone ~/repos/testproject.git ~/testproject"
+    run_ssh "mkdir -p ~/testproject/bin ~/testproject/db"
+
+    # bin/setup script
+    run_ssh "echo '#!/bin/bash' > ~/testproject/bin/setup"
+    run_ssh "echo 'echo Setup complete' >> ~/testproject/bin/setup"
+    run_ssh "chmod +x ~/testproject/bin/setup"
+
+    # bin/rake script for db:dump and db:load
+    run_ssh <<~'SETUP'
+      cat > ~/testproject/bin/rake << 'SCRIPT'
+#!/bin/bash
+case "$1" in
+  db:dump)
+    echo "production data" | gzip > db/data.sql.gz
+    ;;
+  db:load)
+    gunzip -c db/data.sql.gz > /dev/null
+    echo "Data loaded"
+    ;;
+esac
+SCRIPT
+    SETUP
+    run_ssh "chmod +x ~/testproject/bin/rake"
+    run_ssh "cd ~/testproject && git add . && git commit -m 'Initial commit'"
+    run_ssh "cd ~/testproject && git push origin master"
+
+    # Set up local git repo in isolated temp directory
+    setup_local_git_repo
+  end
+
+  def setup_local_git_repo
+    @test_dir = Dir.mktmpdir("bard_test")
+    @ssh_command = "ssh -i #{ssh_key_path} -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null"
+
+    Dir.chdir(@test_dir) do
+      # Clone directly into the temp directory (pass SSH command via env, not global ENV)
+      ssh_url = "ssh://deploy@localhost:#{@ssh_port}/home/deploy/repos/testproject.git"
+      system({ "GIT_SSH_COMMAND" => @ssh_command }, "git clone #{ssh_url} .", out: File::NULL, err: File::NULL)
+
+      # Configure git settings locally in this repo only
+      system("git config user.email 'test@example.com'", out: File::NULL, err: File::NULL)
+      system("git config user.name 'Test User'", out: File::NULL, err: File::NULL)
+      system("git config core.sshCommand '#{@ssh_command}'", out: File::NULL, err: File::NULL)
+
+      # Ensure db directory exists locally
+      FileUtils.mkdir_p("db")
+
+      # Write bard config in the test directory
+      File.write("bard.rb", <<~RUBY)
+        target :production do
+          ssh "deploy@localhost:#{@ssh_port}",
+            path: "testproject",
+            ssh_key: "#{ssh_key_path}"
+          ping false
+        end
+      RUBY
+    end
+  end
+
+  def run_ssh(command)
+    stdout, status = Open3.capture2e(
+      "ssh", "-o", "StrictHostKeyChecking=no", "-o", "UserKnownHostsFile=/dev/null",
+      "-p", @ssh_port.to_s, "-i", ssh_key_path,
+      "deploy@localhost", command
+    )
+    unless status.success?
+      raise PrerequisiteError, "SSH command failed: #{command}\nOutput: #{stdout}"
+    end
+    true
+  end
+
+  def run_bard(command)
+    Dir.chdir(@test_dir) do
+      @stdout, @status = Open3.capture2e("bard #{command}")
+    end
+  end
+
+  def ssh_key_path
+    File.join(ROOT, "spec/acceptance/docker/test_key")
+  end
+
+  def stop_test_server
+    return unless @container
+    @container.stop rescue nil
+    @container.delete(force: true) rescue nil
+  ensure
+    @container = nil
+    @ssh_port = nil
+    FileUtils.rm_rf(@test_dir) if @test_dir
+    @test_dir = nil
+  end
+end
+
+World(TestServerWorld)
+
+Before do
+  start_test_server
+end
+
+After do
+  stop_test_server
+end

data/lib/bard/command.rb

@@ -64,25 +64,44 @@ module Bard
       # Support both new Target (with server attribute) and old Server architecture
       ssh_server = on.respond_to?(:server) ? on.server : on
 
+      # Get options from Target first (for deprecated separate method calls), fall back to SSHServer
+      env_value = on.respond_to?(:env) ? on.env : nil
+      env_value ||= ssh_server.env if ssh_server.respond_to?(:env)
+
+      ssh_key = on.respond_to?(:ssh_key) ? on.ssh_key : nil
+      ssh_key ||= ssh_server.ssh_key if ssh_server.respond_to?(:ssh_key)
+
+      gateway = on.respond_to?(:gateway) ? on.gateway : nil
+      gateway ||= ssh_server.gateway if ssh_server.respond_to?(:gateway)
+
       cmd = command
-      if ssh_server.env
-        cmd = "#{ssh_server.env} #{command}"
-      end
+      cmd = "#{env_value} #{command}" if env_value
+
       unless home
         path = on.respond_to?(:path) ? on.path : ssh_server.path
         cmd = "cd #{path} && #{cmd}" if path
       end
 
-      ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key} " : ""
-      ssh_uri = ssh_server.respond_to?(:ssh_uri) ? ssh_server.ssh_uri : ssh_server.ssh_uri(:ssh)
+      ssh_opts = ["-tt", "-o StrictHostKeyChecking=no", "-o UserKnownHostsFile=/dev/null", "-o LogLevel=ERROR"]
+      ssh_opts << "-i #{ssh_key}" if ssh_key
 
-      cmd = "ssh -tt #{ssh_key} #{ssh_uri} '#{cmd}'"
-
-      if ssh_server.gateway
-        gateway_uri = ssh_server.respond_to?(:ssh_uri) ? ssh_server.gateway : ssh_server.ssh_uri(:gateway)
-        cmd = "ssh -tt #{gateway_uri} \"#{cmd}\""
+      # Handle new SSHServer vs old Server architecture
+      if ssh_server.respond_to?(:host)
+        # New SSHServer - has separate host/port/user
+        ssh_opts << "-p #{ssh_server.port}" if ssh_server.port && ssh_server.port != "22"
+        ssh_opts << "-o ProxyJump=#{gateway}" if gateway
+        ssh_target = "#{ssh_server.user}@#{ssh_server.host}"
+      else
+        # Old Server - uses URI-based ssh_uri
+        ssh_target = ssh_server.ssh_uri
+        if gateway
+          gateway_uri = ssh_server.ssh_uri(:gateway)
+          ssh_opts << "-o ProxyJump=#{gateway_uri}"
+        end
       end
 
+      cmd = "ssh #{ssh_opts.join(' ')} #{ssh_target} '#{cmd}'"
+
       cmd += " 2>&1" if quiet
       cmd
     end

data/lib/bard/copy.rb

@@ -29,10 +29,16 @@ module Bard
 
       ssh_key = ssh_server.ssh_key ? "-i #{ssh_server.ssh_key}" : ""
 
+      ssh_opts = "-o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR"
+
+      # scp uses -P for port (uppercase, unlike ssh's -p)
+      port = ssh_server.port
+      port_opt = port && port.to_s != "22" ? "-P #{port}" : ""
+
       from_and_to = [path, target_or_server.scp_uri(path)]
       from_and_to.reverse! if direction == :from
 
-      command = ["scp", gateway, ssh_key, *from_and_to].join(" ")
+      command = ["scp", ssh_opts, gateway, ssh_key, port_opt, *from_and_to].reject(&:empty?).join(" ")
       Bard::Command.run! command, verbose: verbose
     end
 
@@ -113,7 +119,7 @@ module Bard
       from_str = "-p#{from_uri.port || 22} #{from_uri.user}@#{from_uri.host}"
       to_str = to.rsync_uri(path).sub(%r(/[^/]+$), '/')
 
-      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
+      command = %(ssh -A #{from_str} 'rsync -e \"ssh -A -p#{to_uri.port || 22} -o StrictHostKeyChecking=no -o LogLevel=ERROR\" --delete --info=progress2 -az #{from.path}/#{path} #{to_str}')
       Bard::Command.run! command, verbose: verbose
     end
   end

data/lib/bard/target.rb

@@ -2,11 +2,12 @@ require "uri"
 require "bard/command"
 require "bard/copy"
 require "bard/deploy_strategy"
+require "bard/deprecation"
 
 module Bard
   class Target
-    attr_reader :key, :config, :path
-    attr_accessor :server, :gateway, :ssh_key, :env
+    attr_reader :key, :config
+    attr_accessor :server
 
     def initialize(key, config)
       @key = key
@@ -67,7 +68,7 @@ module Bard
 
         # Auto-configure ping from hostname
         hostname = @server.hostname
-        ping(hostname) if hostname
+        ping("https://#{hostname}") if hostname
       end
     end
 
@@ -78,12 +79,41 @@ module Bard
     # Path configuration
     def path(new_path = nil)
       if new_path
+        Deprecation.warn "Separate `path` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", path: \"#{new_path}\"` (will be removed in v2.0)"
         @path = new_path
       else
         @path || config.project_name
       end
     end
 
+    # Deprecated separate setter methods - use ssh(..., option: value) instead
+    def gateway(value = nil)
+      if value
+        Deprecation.warn "Separate `gateway` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", gateway: \"#{value}\"` (will be removed in v2.0)"
+        @gateway = value
+      else
+        @gateway
+      end
+    end
+
+    def ssh_key(value = nil)
+      if value
+        Deprecation.warn "Separate `ssh_key` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", ssh_key: \"#{value}\"` (will be removed in v2.0)"
+        @ssh_key = value
+      else
+        @ssh_key
+      end
+    end
+
+    def env(value = nil)
+      if value
+        Deprecation.warn "Separate `env` call is deprecated; pass as keyword argument to `ssh` instead, e.g., `ssh \"user@host\", env: \"#{value}\"` (will be removed in v2.0)"
+        @env = value
+      else
+        @env
+      end
+    end
+
     # Ping configuration
     def ping(*urls)
       if urls.empty?
@@ -134,6 +164,18 @@ module Bard
       end
     end
 
+    # Deprecated strategy configuration methods
+    def strategy(name)
+      Deprecation.warn "`strategy` is deprecated; use the strategy method directly, e.g., `#{name} \"url\"` instead of `strategy :#{name}` (will be removed in v2.0)"
+      @deploy_strategy = name
+    end
+
+    def option(key, value)
+      Deprecation.warn "`option` is deprecated; pass options as keyword arguments to the strategy method, e.g., `jets \"url\", #{key}: #{value.inspect}` (will be removed in v2.0)"
+      @strategy_options_hash[@deploy_strategy] ||= {}
+      @strategy_options_hash[@deploy_strategy][key] = value
+    end
+
     def strategy_options(strategy_name)
       @strategy_options_hash[strategy_name] || {}
     end
@@ -177,38 +219,39 @@ module Bard
     # Remote command execution
     def run!(command, home: false, verbose: false, quiet: false)
       require_capability!(:ssh)
-      Command.run!(command, on: server, home: home, verbose: verbose, quiet: quiet)
+      Command.run!(command, on: self, home: home, verbose: verbose, quiet: quiet)
     end
 
     def run(command, home: false, verbose: false, quiet: false)
       require_capability!(:ssh)
-      Command.run(command, on: server, home: home, verbose: verbose, quiet: quiet)
+      Command.run(command, on: self, home: home, verbose: verbose, quiet: quiet)
     end
 
     def exec!(command, home: false)
       require_capability!(:ssh)
-      Command.exec!(command, on: server, home: home)
+      Command.exec!(command, on: self, home: home)
     end
 
     # File transfer
     def copy_file(path, to:, verbose: false)
       require_capability!(:ssh)
-      to.require_capability!(:ssh)
+      to.require_capability!(:ssh) if to.respond_to?(:require_capability!)
       Copy.file(path, from: self, to: to, verbose: verbose)
     end
 
     def copy_dir(path, to:, verbose: false)
       require_capability!(:ssh)
-      to.require_capability!(:ssh)
+      to.require_capability!(:ssh) if to.respond_to?(:require_capability!)
       Copy.dir(path, from: self, to: to, verbose: verbose)
     end
 
     # URI methods for compatibility
     def scp_uri(file_path = nil)
-      uri = URI("scp://#{ssh_uri}")
-      uri.path = "/#{path}"
-      uri.path += "/#{file_path}" if file_path
-      uri
+      # Use traditional scp format: user@host:path (relative to home)
+      # Port is NOT included here - it must be passed via -P flag to scp
+      full_path = path
+      full_path += "/#{file_path}" if file_path
+      "#{server.user}@#{server.host}:#{full_path}"
     end
 
     def rsync_uri(file_path = nil)

data/lib/bard/version.rb

@@ -1,4 +1,4 @@
 module Bard
-  VERSION = "1.8.0.beta"
+  VERSION = "1.8.0.beta2"
 end
 

data/spec/acceptance/docker/Dockerfile

@@ -3,10 +3,11 @@ FROM ubuntu:22.04
 # Prevent interactive prompts
 ENV DEBIAN_FRONTEND=noninteractive
 
-# Install SSH server and basic tools
+# Install SSH server, git, and basic tools
 RUN apt-get update && \
     apt-get install -y \
     openssh-server \
+    git \
     sudo \
     && rm -rf /var/lib/apt/lists/*
 

data/spec/bard/command_spec.rb

@@ -11,7 +11,7 @@ describe Bard::Command do
     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])
+      expect(Open3).to receive(:capture3).with("ssh -tt -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR user@example.com 'cd /path/to && ls -l'").and_return(["output", "", 0])
       Bard::Command.run "ls -l", on: remote
     end
   end

data/spec/bard/copy_spec.rb

@@ -2,17 +2,17 @@ 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(: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, port: "22", 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)
+      expect(Bard::Command).to receive(:run!).with("scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR 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)
+      expect(Bard::Command).to receive(:run!).with("scp -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR path/to/file user@example.com:/path/to/file", verbose: false)
       Bard::Copy.file "path/to/file", from: local, to: production
     end
   end