test-kitchen 1.3.1 → 1.4.0.beta.1

data/spec/kitchen/driver/base_spec.rb

@@ -31,7 +31,7 @@ module Kitchen
 
     class Dodgy < Base
 
-      no_parallel_for :converge
+      no_parallel_for :setup
     end
 
     class Slow < Base
@@ -70,27 +70,6 @@ describe Kitchen::Driver::Base do
     driver.instance.must_equal instance
   end
 
-  it "#name returns the name of the driver" do
-    driver.name.must_equal "Base"
-  end
-
-  describe "#logger" do
-
-    before  { @klog = Kitchen.logger }
-    after   { Kitchen.logger = @klog }
-
-    it "returns the instance's logger if defined" do
-      driver.send(:logger).must_equal logger
-    end
-
-    it "returns the default logger if instance's logger is not set" do
-      driver = Kitchen::Driver::Base.new(config)
-      Kitchen.logger = "yep"
-
-      driver.send(:logger).must_equal Kitchen.logger
-    end
-  end
-
   it "#puts calls logger.info" do
     driver.send(:puts, "yo")
 
@@ -105,26 +84,16 @@ describe Kitchen::Driver::Base do
     logged_output.string.must_match(/yo\n/)
   end
 
-  [:create, :converge, :setup, :verify, :destroy].each do |action|
+  [:create, :setup, :verify, :destroy].each do |action|
 
     it "has a #{action} method that takes state" do
-      state = Hash.new
-      driver.public_send(action, state).must_be_nil
+      # TODO: revert back
+      # state = Hash.new
+      # driver.public_send(action, state).must_be_nil
+      driver.respond_to?(action)
     end
   end
 
-  it "has a login command that raises ActionFailed by default" do
-    proc { driver.login_command(Hash.new) }.must_raise Kitchen::ActionFailed
-  end
-
-  it "has a default verify dependencies method" do
-    driver.verify_dependencies.must_be_nil
-  end
-
-  it "#busser returns the instance's busser" do
-    driver.send(:busser).must_equal busser
-  end
-
   describe ".no_parallel_for" do
 
     it "registers no serial actions when none are declared" do
@@ -132,7 +101,7 @@ describe Kitchen::Driver::Base do
     end
 
     it "registers a single serial action method" do
-      Kitchen::Driver::Dodgy.serial_actions.must_equal [:converge]
+      Kitchen::Driver::Dodgy.serial_actions.must_equal [:setup]
     end
 
     it "registers multiple serial action methods" do

data/spec/kitchen/driver/dummy_spec.rb

@@ -95,35 +95,6 @@ describe Kitchen::Driver::Dummy do
     end
   end
 
-  describe "#converge" do
-
-    it "calls sleep if :sleep value is greater than 0" do
-      config[:sleep] = 12.5
-      driver.expects(:sleep).with(12.5).returns(true)
-
-      driver.create(state)
-    end
-
-    it "raises ActionFailed if :fail_converge is set" do
-      config[:fail_converge] = true
-
-      proc { driver.converge(state) }.must_raise Kitchen::ActionFailed
-    end
-
-    it "randomly raises ActionFailed if :random_failure is set" do
-      config[:random_failure] = true
-      driver.stubs(:randomly_fail?).returns(true)
-
-      proc { driver.converge(state) }.must_raise Kitchen::ActionFailed
-    end
-
-    it "logs a converge event to INFO" do
-      driver.converge(state)
-
-      logged_output.string.must_match(/^.+ INFO .+ \[Dummy\] Converge on .+$/)
-    end
-  end
-
   describe "#setup" do
 
     it "calls sleep if :sleep value is greater than 0" do

data/spec/kitchen/driver/ssh_base_spec.rb

@@ -19,6 +19,41 @@
 require_relative "../../spec_helper"
 
 require "kitchen"
+require "kitchen/transport/ssh"
+require "kitchen/verifier/busser"
+
+module Kitchen
+
+  module Driver
+
+    class BackCompat < Kitchen::Driver::SSHBase
+
+      def use_run_remote(state, command)
+        connection = Kitchen::SSH.new(*build_ssh_args(state))
+        run_remote(command, connection)
+      end
+
+      def use_transfer_path(state, locals, remote)
+        connection = Kitchen::SSH.new(*build_ssh_args(state))
+        transfer_path(locals, remote, connection)
+      end
+    end
+
+    class SpeedyCompat < Kitchen::Driver::SSHBase
+    end
+
+    class DodgyCompat < Kitchen::Driver::SSHBase
+
+      no_parallel_for :converge
+    end
+
+    class SlowCompat < Kitchen::Driver::SSHBase
+
+      no_parallel_for :create, :destroy
+      no_parallel_for :verify
+    end
+  end
+end
 
 describe Kitchen::Driver::SSHBase do
 
@@ -27,12 +62,18 @@ describe Kitchen::Driver::SSHBase do
   let(:config)        { Hash.new }
   let(:state)         { Hash.new }
 
-  let(:busser) do
-    stub(
-      :setup_cmd  => "setup",
-      :sync_cmd   => "sync",
-      :run_cmd    => "run"
-    )
+  let(:verifier) do
+    v = mock("busser")
+    v.responds_like_instance_of(Kitchen::Verifier::Busser)
+    v.stubs(:install_command).returns("install")
+    v.stubs(:init_command).returns("init")
+    v.stubs(:prepare_command).returns("prepare")
+    v.stubs(:run_command).returns("run")
+    v.stubs(:create_sandbox).returns(true)
+    v.stubs(:cleanup_sandbox).returns(true)
+    v.stubs(:sandbox_path).returns("/tmp/sandbox")
+    v.stubs(:[]).with(:root_path).returns("/tmp/verifier")
+    v
   end
 
   let(:provisioner) do
@@ -47,12 +88,19 @@ describe Kitchen::Driver::SSHBase do
     )
   end
 
+  let(:transport) do
+    t = mock("transport")
+    t.responds_like_instance_of(Kitchen::Transport::Base)
+    t
+  end
+
   let(:instance) do
     stub(
       :name         => "coolbeans",
       :logger       => logger,
-      :busser       => busser,
+      :verifier     => verifier,
       :provisioner  => provisioner,
+      :transport    => transport,
       :to_str       => "instance"
     )
   end
@@ -81,100 +129,48 @@ describe Kitchen::Driver::SSHBase do
   end
 
   # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-  def self.constructs_an_ssh_object
-    describe "constructs an SSH object" do
+  def self.constructs_an_ssh_connection
+    describe "constructs an SSH connection" do
 
       it "with hostname set from state" do
-        Kitchen::SSH.expects(:new).with { |hostname, _username, _opts|
-          hostname.must_equal "fizzy"
+        transport.expects(:connection).with { |state|
+          state[:hostname].must_equal "fizzy"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
       it "with username set from state" do
-        Kitchen::SSH.expects(:new).with { |_hostname, username, _opts|
-          username.must_equal "bork"
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :user_known_hosts_file option set to /dev/null" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:user_known_hosts_file].must_equal "/dev/null"
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :paranoid option set to false" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:paranoid].must_equal false
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :keys_only option set to falsey by default" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys_only].nil?
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :keys_only option set to true if :ssh_key is set in config" do
-        config[:ssh_key] = "wicked"
-
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys_only].must_equal true
+        transport.expects(:connection).with { |state|
+          state[:username].must_equal "bork"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
-      it "with :keys_only option set to true if :ssh_key is set in state" do
-        state[:ssh_key] = "wicked"
-
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys_only].must_equal true
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :keys option set to falsey by default" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys].nil?
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :keys option set to an array if :ssh_key is set in config" do
+      it "with :ssh_key option set from config" do
         config[:ssh_key] = "wicked"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys].must_equal ["wicked"]
+        transport.expects(:connection).with { |state|
+          state[:ssh_key].must_equal "wicked"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
-      it "with :keys option set to an array if :ssh_key is set in state" do
+      it "with :ssh_key option set from state" do
         state[:ssh_key] = "wicked"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:keys].must_equal ["wicked"]
+        transport.expects(:connection).with { |state|
+          state[:ssh_key].must_equal "wicked"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
       it "with :password option set to falsey by default" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:password].nil?
+        transport.expects(:connection).with { |state|
+          state[:password].nil?
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -183,8 +179,8 @@ describe Kitchen::Driver::SSHBase do
       it "with :password option set if given in config" do
         config[:password] = "psst"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:password].must_equal "psst"
+        transport.expects(:connection).with { |state|
+          state[:password].must_equal "psst"
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -193,16 +189,16 @@ describe Kitchen::Driver::SSHBase do
       it "with :password option set if given in state" do
         state[:password] = "psst"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:password].must_equal "psst"
+        transport.expects(:connection).with { |state|
+          state[:password].must_equal "psst"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
       it "with :forward_agent option set to falsey by default" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:forward_agent].nil?
+        transport.expects(:connection).with { |state|
+          state[:forward_agent].nil?
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -211,8 +207,8 @@ describe Kitchen::Driver::SSHBase do
       it "with :forward_agent option set if given in config" do
         config[:forward_agent] = "yeah?"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:forward_agent].must_equal "yeah?"
+        transport.expects(:connection).with { |state|
+          state[:forward_agent].must_equal "yeah?"
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -221,16 +217,16 @@ describe Kitchen::Driver::SSHBase do
       it "with :forward_agent option set if given in state" do
         state[:forward_agent] = "yeah?"
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:forward_agent].must_equal "yeah?"
+        transport.expects(:connection).with { |state|
+          state[:forward_agent].must_equal "yeah?"
         }.returns(stub(:login_command => stub))
 
         cmd
       end
 
       it "with :port option set to 22 by default" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:port].must_equal 22
+        transport.expects(:connection).with { |state|
+          state[:port].must_equal 22
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -239,8 +235,8 @@ describe Kitchen::Driver::SSHBase do
       it "with :port option set if customized in config" do
         config[:port] = 1234
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:port].must_equal 1234
+        transport.expects(:connection).with { |state|
+          state[:port].must_equal 1234
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -249,16 +245,8 @@ describe Kitchen::Driver::SSHBase do
       it "with :port option set if customized in state" do
         state[:port] = 9999
 
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:port].must_equal 9999
-        }.returns(stub(:login_command => stub))
-
-        cmd
-      end
-
-      it "with :logger option set to driver's logger" do
-        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
-          opts[:logger].must_equal logger
+        transport.expects(:connection).with { |state|
+          state[:port].must_equal 9999
         }.returns(stub(:login_command => stub))
 
         cmd
@@ -277,16 +265,18 @@ describe Kitchen::Driver::SSHBase do
     end
 
     it "returns a LoginCommand" do
-      cmd.must_be_instance_of Kitchen::LoginCommand
+      transport.stubs(:connection).returns(stub(:login_command => "command"))
+
+      cmd.must_equal "command"
     end
 
-    constructs_an_ssh_object
+    constructs_an_ssh_connection
   end
 
   describe "#converge" do
 
     let(:cmd)         { driver.converge(state) }
-    let(:connection)  { stub(:exec => true) }
+    let(:connection)  { stub(:execute => true, :upload => true) }
 
     before do
       state[:hostname] = "fizzy"
@@ -301,17 +291,17 @@ describe Kitchen::Driver::SSHBase do
       FakeFS::FileSystem.clear
     end
 
-    constructs_an_ssh_object
+    constructs_an_ssh_connection
 
     it "creates the sandbox" do
-      Kitchen::SSH.stubs(:new).yields(connection)
+      transport.stubs(:connection).yields(connection)
       provisioner.expects(:create_sandbox)
 
       cmd
     end
 
     it "ensures that the sandbox is cleaned up" do
-      Kitchen::SSH.stubs(:new).raises
+      transport.stubs(:connection).raises
       provisioner.expects(:cleanup_sandbox)
 
       begin
@@ -321,28 +311,28 @@ describe Kitchen::Driver::SSHBase do
     end
 
     it "invokes the provisioner commands over ssh" do
-      Kitchen::SSH.stubs(:new).yields(connection)
+      transport.stubs(:connection).yields(connection)
       order = sequence("order")
-      connection.expects(:exec).with("install").in_sequence(order)
-      connection.expects(:exec).with("init").in_sequence(order)
-      connection.expects(:exec).with("prepare").in_sequence(order)
-      connection.expects(:exec).with("run").in_sequence(order)
+      connection.expects(:execute).with("install").in_sequence(order)
+      connection.expects(:execute).with("init").in_sequence(order)
+      connection.expects(:execute).with("prepare").in_sequence(order)
+      connection.expects(:execute).with("run").in_sequence(order)
 
       cmd
     end
 
     it "invokes the #install_command with :http_proxy set in config" do
       config[:http_proxy] = "http://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env http_proxy=http://proxy install")
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with("env http_proxy=http://proxy install")
 
       cmd
     end
 
     it "invokes the #install_command with :https_proxy set in config" do
       config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env https_proxy=https://proxy install")
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with("env https_proxy=https://proxy install")
 
       cmd
     end
@@ -350,8 +340,8 @@ describe Kitchen::Driver::SSHBase do
     it "invokes the #install_command with :http_proxy & :https_proxy set" do
       config[:http_proxy] = "http://proxy"
       config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with(
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with(
         "env http_proxy=http://proxy https_proxy=https://proxy install")
 
       cmd
@@ -360,13 +350,13 @@ describe Kitchen::Driver::SSHBase do
     describe "transferring files" do
 
       before do
-        Kitchen::SSH.stubs(:new).yields(connection)
-        connection.stubs(:upload_path!)
+        transport.stubs(:connection).yields(connection)
+        connection.stubs(:upload)
         FileUtils.mkdir_p "/tmp/sandbox/stuff"
       end
 
       it "uploads files" do
-        connection.expects(:upload_path!).with("/tmp/sandbox/stuff", "/rooty")
+        connection.expects(:upload).with(["/tmp/sandbox/stuff"], "/rooty")
 
         cmd
       end
@@ -384,29 +374,16 @@ describe Kitchen::Driver::SSHBase do
         logged_output.string.must_match(/DEBUG -- : Transfer complete$/)
       end
 
-      it "raises an ActionFailed on transfer when SSHFailed is raised" do
-        connection.stubs(:upload_path!).raises(Kitchen::SSHFailed.new("dang"))
-
-        proc { cmd }.must_raise Kitchen::ActionFailed
-      end
-
-      it "raises an ActionFailed on exec when Net::SSH:Exception is raised" do
-        connection.stubs(:upload_path!).raises(Net::SSH::Exception.new("dang"))
+      it "raises an ActionFailed on transfer when SshFailed is raised" do
+        connection.stubs(:upload).raises(Kitchen::Transport::SshFailed.new("dang"))
 
         proc { cmd }.must_raise Kitchen::ActionFailed
       end
     end
 
-    it "raises an ActionFailed on exec when SSHFailed is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Kitchen::SSHFailed.new("dang"))
-
-      proc { cmd }.must_raise Kitchen::ActionFailed
-    end
-
-    it "raises an ActionFailed on exec when Net::SSH:Exception is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Net::SSH::Exception.new("dang"))
+    it "raises an ActionFailed on execute when SshFailed is raised" do
+      transport.stubs(:connection).yields(connection)
+      connection.stubs(:execute).raises(Kitchen::Transport::SshFailed.new("dang"))
 
       proc { cmd }.must_raise Kitchen::ActionFailed
     end
@@ -422,58 +399,44 @@ describe Kitchen::Driver::SSHBase do
       state[:username] = "bork"
     end
 
-    constructs_an_ssh_object
-
-    it "doesn't invoke an ssh command if busser#setup_cmd is nil" do
-      busser.stubs(:setup_cmd).returns(nil)
-      Kitchen::SSH.stubs(:new).yields(connection)
-
-      cmd
-    end
+    constructs_an_ssh_connection
 
-    it "invokes the busser#setup_cmd over ssh" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("setup")
+    it "invokes the Verifier#install_command over ssh" do
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with("install")
 
       cmd
     end
 
-    it "invokes the busser#setup_cmd with :http_proxy set in config" do
+    it "invokes the Verifier#install_command with :http_proxy set in config" do
       config[:http_proxy] = "http://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env http_proxy=http://proxy setup")
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with("env http_proxy=http://proxy install")
 
       cmd
     end
 
-    it "invokes the busser#setup_cmd with :https_proxy set in config" do
+    it "invokes the Verifier#install_command with :https_proxy set in config" do
       config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env https_proxy=https://proxy setup")
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with("env https_proxy=https://proxy install")
 
       cmd
     end
 
-    it "invokes the busser#setup_cmd with :http_proxy & :https_proxy set" do
+    it "invokes the Verifier#install_command with :http_proxy & :https_proxy set" do
       config[:http_proxy] = "http://proxy"
       config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with(
-        "env http_proxy=http://proxy https_proxy=https://proxy setup")
+      transport.stubs(:connection).yields(connection)
+      connection.expects(:execute).with(
+        "env http_proxy=http://proxy https_proxy=https://proxy install")
 
       cmd
     end
 
-    it "raises an ActionFailed when SSHFailed is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Kitchen::SSHFailed.new("dang"))
-
-      proc { cmd }.must_raise Kitchen::ActionFailed
-    end
-
-    it "raises an ActionFailed when Net::SSH:Exception is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Net::SSH::Exception.new("dang"))
+    it "raises an ActionFailed when SshFailed is raised" do
+      transport.stubs(:connection).yields(connection)
+      connection.stubs(:execute).raises(Kitchen::Transport::SshFailed.new("dang"))
 
       proc { cmd }.must_raise Kitchen::ActionFailed
     end
@@ -482,86 +445,100 @@ describe Kitchen::Driver::SSHBase do
   describe "#verify" do
 
     let(:cmd)         { driver.verify(state) }
-    let(:connection)  { mock }
+    let(:connection)  { stub(:execute => true, :upload => true) }
 
     before do
       state[:hostname] = "fizzy"
       state[:username] = "bork"
+      transport.stubs(:connection).yields(connection)
     end
 
-    constructs_an_ssh_object
+    constructs_an_ssh_connection
 
-    it "doesn't invoke an ssh command if busser#sync_cmd & #run_cmd are nil" do
-      busser.stubs(:sync_cmd).returns(nil)
-      busser.stubs(:run_cmd).returns(nil)
-      Kitchen::SSH.stubs(:new).yields(connection)
+    it "creates the sandbox" do
+      verifier.expects(:create_sandbox)
 
       cmd
     end
 
-    it "doesn't invoke an ssh command for busser#sync_cmd if nil" do
-      busser.stubs(:sync_cmd).returns(nil)
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("run")
+    it "ensures that the sandbox is cleanup up" do
+      transport.stubs(:connection).raises
+      verifier.expects(:cleanup_sandbox)
 
-      cmd
+      begin
+        cmd
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
     end
 
-    it "doesn't invoke an ssh command for busser#run_cmd if nil" do
-      busser.stubs(:run_cmd).returns(nil)
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("sync")
+    it "invokes the verifier commands over the transport" do
+      order = sequence("order")
+      connection.expects(:execute).with("init").in_sequence(order)
+      connection.expects(:execute).with("prepare").in_sequence(order)
+      connection.expects(:execute).with("run").in_sequence(order)
 
       cmd
     end
 
-    it "invokes the busser#sync_cmd & #run_cmd over ssh" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("sync")
-      connection.expects(:exec).with("run")
+    %W[init prepare run].each do |phase|
+      it "invokes Verifier##{phase}_command over ssh" do
+        connection.expects(:execute).with(phase)
 
-      cmd
-    end
+        cmd
+      end
 
-    it "invokes the busser#setup_cmd with :http_proxy set in config" do
-      busser.stubs(:run_cmd).returns(nil)
-      config[:http_proxy] = "http://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env http_proxy=http://proxy sync")
+      it "invokes Verifier##{phase}_command with :http_proxy set in config" do
+        config[:http_proxy] = "http://proxy"
+        connection.expects(:execute).with("env http_proxy=http://proxy #{phase}")
 
+        cmd
+      end
+
+      it "invokes Verifier##{phase}_command with :https_proxy set in config" do
+        config[:https_proxy] = "https://proxy"
+        connection.expects(:execute).with("env https_proxy=https://proxy #{phase}")
+
+        cmd
+      end
+
+      it "invokes Verifier##{phase}_command with :http_proxy & :https_proxy set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+        connection.expects(:execute).with(
+          "env http_proxy=http://proxy https_proxy=https://proxy #{phase}")
+
+        cmd
+      end
+    end
+
+    it "logs to info" do
       cmd
+
+      logged_output.string.
+        must_match(/INFO -- : Transferring files to instance$/)
     end
 
-    it "invokes the busser#setup_cmd with :https_proxy set in config" do
-      busser.stubs(:run_cmd).returns(nil)
-      config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("env https_proxy=https://proxy sync")
+    it "uploads sandbox files" do
+      connection.expects(:upload).with([], "/tmp/verifier")
 
       cmd
     end
 
-    it "invokes the busser#setup_cmd with :http_proxy & :https_proxy set" do
-      busser.stubs(:run_cmd).returns(nil)
-      config[:http_proxy] = "http://proxy"
-      config[:https_proxy] = "https://proxy"
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with(
-        "env http_proxy=http://proxy https_proxy=https://proxy sync")
-
+    it "logs to debug" do
       cmd
+
+      logged_output.string.must_match(/DEBUG -- : Transfer complete$/)
     end
 
-    it "raises an ActionFailed when SSHFailed is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Kitchen::SSHFailed.new("dang"))
+    it "raises an ActionFailed on transfer when TransportFailed is raised" do
+      connection.stubs(:upload).
+        raises(Kitchen::Transport::TransportFailed.new("dang"))
 
       proc { cmd }.must_raise Kitchen::ActionFailed
     end
 
-    it "raises an ActionFailed when Net::SSH:Exception is raised" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.stubs(:exec).raises(Net::SSH::Exception.new("dang"))
+    it "raises an ActionFailed when SSHFailed is raised" do
+      connection.stubs(:execute).raises(Kitchen::Transport::SshFailed.new("dang"))
 
       proc { cmd }.must_raise Kitchen::ActionFailed
     end
@@ -572,19 +549,21 @@ describe Kitchen::Driver::SSHBase do
     let(:cmd)         { driver.ssh(["host", "user", { :one => "two" }], "go") }
     let(:connection)  { mock }
 
-    it "creates an SSH object" do
-      Kitchen::SSH.expects(:new).with { |hostname, username, opts|
-        hostname.must_equal "host"
-        username.must_equal "user"
-        opts.must_equal(:one => "two")
-      }
+    it "creates an SSH connection" do
+      connection.stubs(:execute)
+      transport.expects(:connection).with(
+        :hostname => "host",
+        :username => "user",
+        :port => 22,
+        :one => "two"
+      ).yields(connection)
 
       cmd
     end
 
     it "invokes the command over ssh" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("go")
+      transport.expects(:connection).yields(connection)
+      connection.expects(:execute).with("go")
 
       cmd
     end
@@ -600,18 +579,19 @@ describe Kitchen::Driver::SSHBase do
       state[:username] = "bork"
     end
 
-    it "creates an SSH object" do
-      Kitchen::SSH.expects(:new).with { |hostname, username, _opts|
-        hostname.must_equal "fizzy"
-        username.must_equal "bork"
-      }
+    it "creates an SSH connection" do
+      transport.expects(:connection).with(
+        :hostname => "fizzy",
+        :username => "bork",
+        :port => 22
+      )
 
       cmd
     end
 
     it "invokes the command over ssh" do
-      Kitchen::SSH.stubs(:new).yields(connection)
-      connection.expects(:exec).with("shipit")
+      transport.expects(:connection).yields(connection)
+      connection.expects(:execute).with("shipit")
 
       cmd
     end
@@ -623,22 +603,386 @@ describe Kitchen::Driver::SSHBase do
       driver.send(:wait_for_sshd, "host", "user", :one => "two")
     end
 
-    it "creates an SSH object with merged options" do
-      Kitchen::SSH.expects(:new).with { |hostname, username, opts|
-        hostname.must_equal "host"
-        username.must_equal "user"
-        opts.must_equal(:one => "two", :logger => logger)
-      }.returns(stub(:wait => true))
+    it "creates an SSH connection with merged options" do
+      transport.expects(:connection).with(
+        :hostname => "host",
+        :username => "user",
+        :port => 22,
+        :one => "two"
+      ).returns(stub(:wait_until_ready => true))
 
       cmd
     end
 
-    it "calls wait on the SSH object" do
-      ssh = mock
-      Kitchen::SSH.stubs(:new).returns(ssh)
-      ssh.expects(:wait)
+    it "calls wait on the SSH connection" do
+      connection = mock
+      transport.expects(:connection).returns(connection)
+      connection.expects(:wait_until_ready)
 
       cmd
     end
   end
+
+  describe "to maintain backwards compatibility" do
+
+    let(:driver) do
+      Kitchen::Driver::BackCompat.new(config).finalize_config!(instance)
+    end
+
+    it "#instance returns its instance" do
+      driver.instance.must_equal instance
+    end
+
+    it "#name returns the name of the driver" do
+      driver.name.must_equal "BackCompat"
+    end
+
+    describe "#logger" do
+
+      before  { @klog = Kitchen.logger }
+      after   { Kitchen.logger = @klog }
+
+      it "returns the instance's logger if defined" do
+        driver.send(:logger).must_equal logger
+      end
+
+      it "returns the default logger if instance's logger is not set" do
+        driver = Kitchen::Driver::BackCompat.new(config)
+        Kitchen.logger = "yep"
+
+        driver.send(:logger).must_equal Kitchen.logger
+      end
+    end
+
+    it "#puts calls logger.info" do
+      driver.send(:puts, "yo")
+
+      logged_output.string.must_match(/I, /)
+      logged_output.string.must_match(/yo\n/)
+    end
+
+    it "#print calls logger.info" do
+      driver.send(:print, "yo")
+
+      logged_output.string.must_match(/I, /)
+      logged_output.string.must_match(/yo\n/)
+    end
+
+    it "has a default verify dependencies method" do
+      driver.verify_dependencies.must_be_nil
+    end
+
+    it "#busser returns the instance's verifier" do
+      driver.send(:busser).must_equal verifier
+    end
+
+    describe ".no_parallel_for" do
+
+      it "registers no serial actions when none are declared" do
+        Kitchen::Driver::SpeedyCompat.serial_actions.must_equal nil
+      end
+
+      it "registers a single serial action method" do
+        Kitchen::Driver::DodgyCompat.serial_actions.must_equal [:converge]
+      end
+
+      it "registers multiple serial action methods" do
+        actions = Kitchen::Driver::SlowCompat.serial_actions
+
+        actions.must_include :create
+        actions.must_include :verify
+        actions.must_include :destroy
+      end
+
+      it "raises a ClientError if value is not an action method" do
+        proc {
+          Class.new(Kitchen::Driver::BackCompat) {
+            no_parallel_for :telling_stories
+          }
+        }.must_raise Kitchen::ClientError
+      end
+    end
+
+    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+    def self.constructs_an_ssh_object
+      it "with hostname set from state" do
+        Kitchen::SSH.expects(:new).with { |hostname, _username, _opts|
+          hostname.must_equal "fizzy"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with username set from state" do
+        Kitchen::SSH.expects(:new).with { |_hostname, username, _opts|
+          username.must_equal "bork"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :user_known_hosts_file option set to /dev/null" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:user_known_hosts_file].must_equal "/dev/null"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :paranoid option set to false" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:paranoid].must_equal false
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys_only option set to falsey by default" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys_only].nil?
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys_only option set to true if :ssh_key is set in config" do
+        config[:ssh_key] = "wicked"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys_only].must_equal true
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys_only option set to true if :ssh_key is set in state" do
+        state[:ssh_key] = "wicked"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys_only].must_equal true
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys option set to falsey by default" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys].nil?
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys option set to an array if :ssh_key is set in config" do
+        config[:ssh_key] = "wicked"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys].must_equal ["wicked"]
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :keys option set to an array if :ssh_key is set in state" do
+        state[:ssh_key] = "wicked"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:keys].must_equal ["wicked"]
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :password option set to falsey by default" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:password].nil?
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :password option set if given in config" do
+        config[:password] = "psst"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:password].must_equal "psst"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :password option set if given in state" do
+        state[:password] = "psst"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:password].must_equal "psst"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :forward_agent option set to falsey by default" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:forward_agent].nil?
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :forward_agent option set if given in config" do
+        config[:forward_agent] = "yeah?"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:forward_agent].must_equal "yeah?"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :forward_agent option set if given in state" do
+        state[:forward_agent] = "yeah?"
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:forward_agent].must_equal "yeah?"
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :port option set to 22 by default" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:port].must_equal 22
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :port option set if customized in config" do
+        config[:port] = 1234
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:port].must_equal 1234
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :port option set if customized in state" do
+        state[:port] = 9999
+
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:port].must_equal 9999
+        }.returns(connection)
+
+        cmd
+      end
+
+      it "with :logger option set to driver's logger" do
+        Kitchen::SSH.expects(:new).with { |_hostname, _username, opts|
+          opts[:logger].must_equal logger
+        }.returns(connection)
+
+        cmd
+      end
+    end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
+    describe "#run_remote" do
+
+      let(:cmd)         { driver.use_run_remote(state, "huh") }
+      let(:connection)  { stub(:exec => true) }
+
+      before do
+        state[:hostname] = "fizzy"
+        state[:username] = "bork"
+      end
+
+      constructs_an_ssh_object
+
+      it "invokes the #install_command with :http_proxy set in config" do
+        config[:http_proxy] = "http://proxy"
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.expects(:exec).with("env http_proxy=http://proxy huh")
+
+        cmd
+      end
+
+      it "invokes the #install_command with :https_proxy set in config" do
+        config[:https_proxy] = "https://proxy"
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.expects(:exec).with("env https_proxy=https://proxy huh")
+
+        cmd
+      end
+
+      it "invokes the #install_command with :http_proxy & :https_proxy set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.expects(:exec).with(
+          "env http_proxy=http://proxy https_proxy=https://proxy huh")
+
+        cmd
+      end
+
+      it "doesn't invoke an ssh command if command is nil" do
+        Kitchen::SSH.stubs(:new).returns(mock)
+
+        driver.use_run_remote(state, nil)
+      end
+
+      it "raises an ActionFailed on transfer when SSHFailed is raised" do
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.stubs(:exec).raises(Kitchen::SSHFailed.new("dang"))
+
+        proc { cmd }.must_raise Kitchen::ActionFailed
+      end
+
+      it "raises an ActionFailed on exec when Net::SSH:Exception is raised" do
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.stubs(:exec).raises(Net::SSH::Exception.new("dang"))
+
+        proc { cmd }.must_raise Kitchen::ActionFailed
+      end
+    end
+
+    describe "#transfer_path" do
+
+      let(:cmd)         { driver.use_transfer_path(state, ["nope"], "nadda") }
+      let(:connection)  { stub(:upload_path! => true) }
+
+      before do
+        state[:hostname] = "fizzy"
+        state[:username] = "bork"
+      end
+
+      constructs_an_ssh_object
+
+      it "doesn't invoke an scp command if locals is nil" do
+        Kitchen::SSH.stubs(:new).returns(mock)
+
+        driver.use_transfer_path(state, nil, "nope")
+      end
+
+      it "doesn't invoke an scp command if locals is an empty array" do
+        Kitchen::SSH.stubs(:new).returns(mock)
+
+        driver.use_transfer_path(state, [], "nope")
+      end
+
+      it "raises an ActionFailed on transfer when SSHFailed is raised" do
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.stubs(:upload_path!).raises(Kitchen::SSHFailed.new("dang"))
+
+        proc { cmd }.must_raise Kitchen::ActionFailed
+      end
+
+      it "raises an ActionFailed on exec when Net::SSH:Exception is raised" do
+        Kitchen::SSH.stubs(:new).returns(connection)
+        connection.stubs(:upload_path!).raises(Net::SSH::Exception.new("dang"))
+
+        proc { cmd }.must_raise Kitchen::ActionFailed
+      end
+    end
+  end
 end