test-kitchen 1.3.1 → 1.4.0.beta.1

data/spec/kitchen/login_command_spec.rb

@@ -22,28 +22,47 @@ require "kitchen/login_command"
 
 describe Kitchen::LoginCommand do
 
-  let(:argv) { Array.new }
-  let(:opts) { Hash.new }
+  let(:cmd)   { "" }
+  let(:argv)  { Array.new }
+  let(:opts)  { Hash.new }
 
-  let(:cmd) { Kitchen::LoginCommand.new(argv, opts) }
+  let(:login_command) { Kitchen::LoginCommand.new(cmd, argv, opts) }
 
-  it "#cmd_array defaults to an empty array" do
-    Kitchen::LoginCommand.new(nil, opts).cmd_array.must_equal []
+  it "#command returns the command" do
+    cmd << "one"
+
+    login_command.command.must_equal "one"
+  end
+
+  it "#arguments defaults to an empty array" do
+    Kitchen::LoginCommand.new("echo", nil).arguments.must_equal []
   end
 
-  it "#cmd_array returns the command array from the constructor" do
-    argv.concat(["one", "-o", "two"])
+  it "#arguments returns the command arguments" do
+    argv.concat(["-o", "two"])
 
-    cmd.cmd_array.must_equal ["one", "-o", "two"]
+    login_command.arguments.must_equal ["-o", "two"]
   end
 
   it "#options defaults to an empty hash" do
-    Kitchen::LoginCommand.new(argv, nil).options.must_equal {}
+    Kitchen::LoginCommand.new(cmd, argv, nil).options.must_equal {}
   end
 
   it "#options returns the options hash from the constructor" do
     opts[:cake] = "yummy"
 
-    cmd.options.must_equal(:cake => "yummy")
+    login_command.options.must_equal(:cake => "yummy")
+  end
+
+  it "#exec_args returns an array of arguments for Kernel.exec" do
+    cmd << "alpha"
+    login_command.exec_args.must_equal ["alpha", {}]
+
+    argv.concat(["-o", "beta"])
+    login_command.exec_args.must_equal ["alpha", "-o", "beta", {}]
+
+    opts[:charlie] = "delta"
+    login_command.exec_args.must_equal [
+      "alpha", "-o", "beta", { :charlie => "delta" }]
   end
 end

data/spec/kitchen/platform_spec.rb

@@ -24,10 +24,66 @@ require "kitchen/platform"
 describe Kitchen::Platform do
 
   let(:opts) do; { :name => "plata" }; end
-  let(:platform) { Kitchen::Platform.new(opts) }
+  let(:klass) { Kitchen::Platform }
 
   it "raises an ArgumentError if name is missing" do
     opts.delete(:name)
-    proc { Kitchen::Platform.new(opts) }.must_raise Kitchen::ClientError
+    proc { klass.new(opts) }.must_raise Kitchen::ClientError
+  end
+
+  it "#os_type returns value passed into constructor with :os_type" do
+    klass.new(:name => "p", :os_type => "unix").os_type.must_equal "unix"
+    klass.new(:name => "p", :os_type => "windows").os_type.must_equal "windows"
+    klass.new(:name => "p", :os_type => "unicorn").os_type.must_equal "unicorn"
+    klass.new(:name => "p", :os_type => nil).os_type.must_equal nil
+  end
+
+  it "#os_type defaults to `unix` when not provided" do
+    klass.new(:name => "p").os_type.must_equal "unix"
+  end
+
+  it "#os_type defaults to `windows` if the name starts with 'win'" do
+    klass.new(:name => "win").os_type.must_equal "windows"
+    klass.new(:name => "Win").os_type.must_equal "windows"
+    klass.new(:name => "win7").os_type.must_equal "windows"
+    klass.new(:name => "windows").os_type.must_equal "windows"
+    klass.new(:name => "Windows").os_type.must_equal "windows"
+    klass.new(:name => "windows81").os_type.must_equal "windows"
+    klass.new(:name => "windows-2012").os_type.must_equal "windows"
+  end
+
+  it "#shell_type returns value passed into constructor with :shell_type" do
+    klass.new(:name => "p", :shell_type => "bourne").
+      shell_type.must_equal "bourne"
+    klass.new(:name => "p", :shell_type => "powershell").
+      shell_type.must_equal "powershell"
+    klass.new(:name => "p", :shell_type => "unicorn").
+      shell_type.must_equal "unicorn"
+    klass.new(:name => "p", :shell_type => nil).
+      shell_type.must_equal nil
+  end
+
+  it "#shell_type defaults to `bourne` when not provided" do
+    klass.new(:name => "p").shell_type.must_equal "bourne"
+  end
+
+  it "#shell_type defaults to `powershell` if the name starts with 'windows'" do
+    klass.new(:name => "win").shell_type.must_equal "powershell"
+    klass.new(:name => "Win").shell_type.must_equal "powershell"
+    klass.new(:name => "win7").shell_type.must_equal "powershell"
+    klass.new(:name => "windows").shell_type.must_equal "powershell"
+    klass.new(:name => "Windows").shell_type.must_equal "powershell"
+    klass.new(:name => "windows81").shell_type.must_equal "powershell"
+    klass.new(:name => "windows-2012").shell_type.must_equal "powershell"
+  end
+
+  it "#diagnose returns a hash with sorted keys" do
+    opts[:os_type] = "unikitty"
+    opts[:shell_type] = "wundershell"
+
+    klass.new(opts).diagnose.must_equal(
+      :os_type => "unikitty",
+      :shell_type => "wundershell"
+    )
   end
 end

data/spec/kitchen/provisioner/base_spec.rb

@@ -22,49 +22,201 @@ require "stringio"
 
 require "kitchen"
 
+module Kitchen
+
+  module Provisioner
+
+    class TestingDummy < Kitchen::Provisioner::Base
+
+      attr_reader :called_create_sandbox, :called_cleanup_sandbox
+
+      def install_command
+        "install"
+      end
+
+      def init_command
+        "init"
+      end
+
+      def prepare_command
+        "prepare"
+      end
+
+      def run_command
+        "run"
+      end
+
+      def create_sandbox
+        @called_create_sandbox = true
+      end
+
+      def cleanup_sandbox
+        @called_cleanup_sandbox = true
+      end
+
+      def sandbox_path
+        "/tmp/sandbox"
+      end
+    end
+  end
+end
+
 describe Kitchen::Provisioner::Base do
 
   let(:logged_output)   { StringIO.new }
   let(:logger)          { Logger.new(logged_output) }
+  let(:platform)        { stub(:os_type => nil, :shell_type => nil) }
   let(:config)          { Hash.new }
 
+  let(:transport) do
+    t = mock("transport")
+    t.responds_like_instance_of(Kitchen::Transport::Base)
+    t
+  end
+
   let(:instance) do
-    stub(:name => "coolbeans", :logger => logger)
+    stub(
+      :name => "coolbeans",
+      :to_str => "instance",
+      :logger => logger,
+      :platform => platform,
+      :transport => transport
+    )
   end
 
   let(:provisioner) do
     Kitchen::Provisioner::Base.new(config).finalize_config!(instance)
   end
 
-  it "#name returns the name of the provisioner" do
-    provisioner.name.must_equal "Base"
-  end
-
   describe "configuration" do
 
-    it ":root_path defaults to /tmp/kitchen" do
-      provisioner[:root_path].must_equal "/tmp/kitchen"
+    describe "for unix operating systems" do
+
+      before { platform.stubs(:os_type).returns("unix") }
+
+      it ":root_path defaults to /tmp/kitchen" do
+        provisioner[:root_path].must_equal "/tmp/kitchen"
+      end
+
+      it ":sudo defaults to true" do
+        provisioner[:sudo].must_equal true
+      end
+    end
+
+    describe "for windows operating systems" do
+
+      before { platform.stubs(:os_type).returns("windows") }
+
+      it ":root_path defaults to $env:TEMP\\kitchen" do
+        provisioner[:root_path].must_equal "$env:TEMP\\kitchen"
+      end
+
+      it ":sudo defaults to nil" do
+        provisioner[:sudo].must_equal nil
+      end
+    end
+
+    it ":http_proxy defaults to nil" do
+      provisioner[:http_proxy].must_equal nil
     end
 
-    it ":sudo defaults to true" do
-      provisioner[:sudo].must_equal true
+    it ":http_proxys defaults to nil" do
+      provisioner[:https_proxy].must_equal nil
     end
   end
 
-  describe "#logger" do
+  describe "#call" do
+
+    let(:state) { Hash.new }
+    let(:cmd)   { provisioner.call(state) }
+
+    let(:connection) do
+      c = mock("transport_connection")
+      c.responds_like_instance_of(Kitchen::Transport::Base::Connection)
+      c
+    end
+
+    let(:provisioner) do
+      Kitchen::Provisioner::TestingDummy.new(config).finalize_config!(instance)
+    end
+
+    before do
+      FakeFS.activate!
+      FileUtils.mkdir_p(File.join(provisioner.sandbox_path, "stuff"))
+      transport.stubs(:connection).yields(connection)
+      connection.stubs(:execute)
+      connection.stubs(:upload)
+    end
+
+    after do
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+
+    it "creates the sandbox" do
+      provisioner.expects(:create_sandbox)
+
+      cmd
+    end
+
+    it "ensures that the sandbox is cleanup up" do
+      transport.stubs(:connection).raises
+      provisioner.expects(:cleanup_sandbox)
+
+      begin
+        cmd
+      rescue # rubocop:disable Lint/HandleExceptions
+      end
+    end
+
+    it "yields a connection given the state" do
+      state[:a] = "b"
+      transport.expects(:connection).with(state).yields(connection)
+
+      cmd
+    end
+
+    it "invokes the provisioner commands over the transport" do
+      order = 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 "logs to info" do
+      cmd
+
+      logged_output.string.
+        must_match(/INFO -- : Transferring files to instance$/)
+    end
+
+    it "uploads sandbox files" do
+      connection.expects(:upload).with(["/tmp/sandbox/stuff"], "/tmp/kitchen")
+
+      cmd
+    end
+
+    it "logs to debug" do
+      cmd
+
+      logged_output.string.must_match(/DEBUG -- : Transfer complete$/)
+    end
 
-    before  { @klog = Kitchen.logger }
-    after   { Kitchen.logger = @klog }
+    it "raises an ActionFailed on transfer when TransportFailed is raised" do
+      connection.stubs(:upload).
+        raises(Kitchen::Transport::TransportFailed.new("dang"))
 
-    it "returns the instance's logger" do
-      provisioner.send(:logger).must_equal logger
+      proc { cmd }.must_raise Kitchen::ActionFailed
     end
 
-    it "returns the default logger if instance's logger is not set" do
-      provisioner = Kitchen::Provisioner::Base.new(config)
-      Kitchen.logger = "yep"
+    it "raises an ActionFailed on execute when TransportFailed is raised" do
+      connection.stubs(:execute).
+        raises(Kitchen::Transport::TransportFailed.new("dang"))
 
-      provisioner.send(:logger).must_equal Kitchen.logger
+      proc { cmd }.must_raise Kitchen::ActionFailed
     end
   end
 

data/spec/kitchen/provisioner/chef_base_spec.rb

@@ -25,17 +25,20 @@ describe Kitchen::Provisioner::ChefBase do
 
   let(:logged_output)   { StringIO.new }
   let(:logger)          { Logger.new(logged_output) }
+  let(:platform)        { stub(:os_type => nil) }
+  let(:suite)           { stub(:name => "fries") }
 
   let(:config) do
     { :test_base_path => "/basist", :kitchen_root => "/rooty" }
   end
 
-  let(:suite) do
-    stub(:name => "fries")
-  end
-
   let(:instance) do
-    stub(:name => "coolbeans", :logger => logger, :suite => suite)
+    stub(
+      :name => "coolbeans",
+      :logger => logger,
+      :suite => suite,
+      :platform => platform
+    )
   end
 
   let(:provisioner) do
@@ -48,17 +51,127 @@ describe Kitchen::Provisioner::ChefBase do
 
   describe "configuration" do
 
-    it ":require_chef_omnibus defaults to true" do
-      provisioner[:require_chef_omnibus].must_equal true
+    describe "for unix operating systems" do
+
+      before { platform.stubs(:os_type).returns("unix") }
+
+      it ":chef_omnibus_root has a default" do
+        provisioner[:chef_omnibus_root].must_equal "/opt/chef"
+      end
+
+      it ":chef_omnibus_url has a default" do
+        provisioner[:chef_omnibus_url].
+          must_equal "https://www.chef.io/chef/install.sh"
+      end
+
+      it ":chef_metadata_url defaults to nil" do
+        provisioner[:chef_metadata_url].must_equal(nil)
+      end
     end
 
-    it ":chef_omnibus_url has a default" do
-      provisioner[:chef_omnibus_url].
-        must_equal "https://www.chef.io/chef/install.sh"
+    describe "for windows operating systems" do
+
+      before { platform.stubs(:os_type).returns("windows") }
+
+      it ":chef_omnibus_root has a default" do
+        provisioner[:chef_omnibus_root].
+          must_equal "$env:systemdrive\\opscode\\chef"
+      end
+
+      it ":chef_omnibus_url has a default" do
+        provisioner[:chef_omnibus_url].
+          must_equal "https://www.chef.io/chef/install.sh"
+      end
+
+      describe ":chef_metadata_url" do
+
+        let(:base_url) { "https://www.chef.io/chef/metadata" }
+
+        it "uses :chef_omnibus_url as url base if it ends in install.sh" do
+          config[:chef_omnibus_url] = "https://woot/install.sh"
+
+          provisioner[:chef_metadata_url].must_equal(
+            "https://woot/metadata?p=windows&m=x86_64&pv=2008r2&v=latest"
+          )
+        end
+
+        it "ignores :chef_omnibus_url if it doesn't end in install.sh" do
+          config[:chef_omnibus_url] = "https://woot/other"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=latest"
+        end
+
+        it "defaults to latest package with :require_chef_omnibus = true" do
+          config[:require_chef_omnibus] = true
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=latest"
+        end
+
+        it "defaults to latest package with :require_chef_omnibus = latest" do
+          config[:require_chef_omnibus] = "latest"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=latest"
+        end
+
+        it "defaults to a specific package from :require_chef_omnibus" do
+          config[:require_chef_omnibus] = "11.12.13"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=11.12.13"
+        end
+
+        it "defaults to a maj/min version package from :require_chef_omnibus" do
+          config[:require_chef_omnibus] = 12.1
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=12.1"
+        end
+
+        it "defaults to a major package version from :require_chef_omnibus" do
+          config[:require_chef_omnibus] = "16"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=16"
+        end
+
+        it "defaults to a prerelease package from :require_chef_omnibus" do
+          config[:require_chef_omnibus] = "11.6.0.RC.1"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}?p=windows&m=x86_64&pv=2008r2&v=11.6.0.rc.1"
+        end
+
+        it "defaults to a chefdk package from :chef_omnibus_install_options" do
+          config[:require_chef_omnibus] = true
+          config[:chef_omnibus_install_options] = "-P chefdk"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}-chefdk?p=windows&m=x86_64&pv=2008r2&v=latest"
+        end
+
+        it "defaults to a specfic chefdk from :chef_omnibus_install_options" do
+          config[:require_chef_omnibus] = "0.3.6"
+          config[:chef_omnibus_install_options] = "-a other -P chefdk -B okay"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}-chefdk?p=windows&m=x86_64&pv=2008r2&v=0.3.6"
+        end
+
+        it "defaults to a maj/min chefdk from :chef_omnibus_install_options" do
+          config[:require_chef_omnibus] = "0.3"
+          config[:chef_omnibus_install_options] = "-P chefdk -B okay"
+
+          provisioner[:chef_metadata_url].
+            must_equal "#{base_url}-chefdk?p=windows&m=x86_64&pv=2008r2&v=0.3"
+        end
+      end
     end
 
-    it ":chef_omnibus_root has a default" do
-      provisioner[:chef_omnibus_root].must_equal "/opt/chef"
+    it ":require_chef_omnibus defaults to true" do
+      provisioner[:require_chef_omnibus].must_equal true
     end
 
     it ":chef_omnibus_install_options defaults to nil" do
@@ -114,136 +227,373 @@ describe Kitchen::Provisioner::ChefBase do
 
   describe "#install_command" do
 
-    it "returns nil if :require_chef_omnibus is falsey" do
-      config[:require_chef_omnibus] = false
+    let(:cmd) { provisioner.install_command }
 
-      provisioner.install_command.must_equal nil
-    end
+    describe "for bourne shells" do
 
-    it "uses bourne shell (sh)" do
-      provisioner.install_command.must_match(/\Ash -c '$/)
-    end
+      before { platform.stubs(:shell_type).returns("bourne") }
 
-    it "ends with a single quote" do
-      provisioner.install_command.must_match(/'\Z/)
-    end
+      it "returns nil if :require_chef_omnibus is falsey" do
+        config[:require_chef_omnibus] = false
 
-    it "installs chef using :chef_omnibus_url, if necessary" do
-      config[:chef_omnibus_url] = "FROM_HERE"
+        cmd.must_equal nil
+      end
 
-      provisioner.install_command.must_match regexify(
-        "do_download FROM_HERE /tmp/install.sh")
-    end
+      it "uses bourne shell (sh)" do
+        cmd.must_match(/\Ash -c '$/)
+      end
 
-    it "will install a specific version of chef, if necessary" do
-      config[:require_chef_omnibus] = "1.2.3"
+      it "ends with a single quote" do
+        cmd.must_match(/'\Z/)
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -v 1.2.3")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (1.2.3)", :partial_line)
-    end
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
 
-    it "will install a major/minor version of chef, if necessary" do
-      config[:require_chef_omnibus] = "11.10"
+        cmd.lines.to_a[1..2].must_equal([
+          %{http_proxy="http://proxy"; export http_proxy\n},
+          %{HTTP_PROXY="http://proxy"; export HTTP_PROXY\n}
+        ])
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -v 11.10")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (11.10)", :partial_line)
-    end
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
 
-    it "will install a major version of chef, if necessary" do
-      config[:require_chef_omnibus] = "12"
+        cmd.lines.to_a[1..2].must_equal([
+          %{https_proxy="https://proxy"; export https_proxy\n},
+          %{HTTPS_PROXY="https://proxy"; export HTTPS_PROXY\n}
+        ])
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -v 12")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (12)", :partial_line)
-    end
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
 
-    it "will install a downcaased version string of chef, if necessary" do
-      config[:require_chef_omnibus] = "10.1.0.RC.1"
+        cmd.lines.to_a[1..4].must_equal([
+          %{http_proxy="http://proxy"; export http_proxy\n},
+          %{HTTP_PROXY="http://proxy"; export HTTP_PROXY\n},
+          %{https_proxy="https://proxy"; export https_proxy\n},
+          %{HTTPS_PROXY="https://proxy"; export HTTPS_PROXY\n}
+        ])
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -v 10.1.0.rc.1")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (10.1.0.rc.1)", :partial_line)
-    end
+      it "installs chef using :chef_omnibus_url, if necessary" do
+        config[:chef_omnibus_url] = "FROM_HERE"
 
-    it "will install the latest of chef, if necessary" do
-      config[:require_chef_omnibus] = "latest"
+        cmd.must_match regexify(%{chef_omnibus_url="FROM_HERE"})
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh ")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (always install latest version)",
-        :partial_line
-      )
-    end
+      it "will install a specific version of chef, if necessary" do
+        config[:require_chef_omnibus] = "1.2.3"
 
-    it "will install a of chef, unless it exists" do
-      config[:require_chef_omnibus] = true
+        cmd.must_match regexify(%{install_flags="-v 1.2.3"})
+        cmd.must_match regexify(%{pretty_version="1.2.3"})
+        cmd.must_match regexify(%{version="1.2.3"})
+      end
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh ")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (install only if missing)", :partial_line)
-    end
+      it "will install a major/minor version of chef, if necessary" do
+        config[:require_chef_omnibus] = "11.10"
+
+        cmd.must_match regexify(%{install_flags="-v 11.10"})
+        cmd.must_match regexify(%{pretty_version="11.10"})
+        cmd.must_match regexify(%{version="11.10"})
+      end
+
+      it "will install a major version of chef, if necessary" do
+        config[:require_chef_omnibus] = "12"
+
+        cmd.must_match regexify(%{install_flags="-v 12"})
+        cmd.must_match regexify(%{pretty_version="12"})
+        cmd.must_match regexify(%{version="12"})
+      end
+
+      it "will install a downcaased version string of chef, if necessary" do
+        config[:require_chef_omnibus] = "10.1.0.RC.1"
+
+        cmd.must_match regexify(%{install_flags="-v 10.1.0.rc.1"})
+        cmd.must_match regexify(%{pretty_version="10.1.0.rc.1"})
+        cmd.must_match regexify(%{version="10.1.0.rc.1"})
+      end
+
+      it "will install the latest of chef, if necessary" do
+        config[:require_chef_omnibus] = "latest"
+
+        cmd.must_match regexify(%{install_flags=""})
+        cmd.must_match regexify(%{pretty_version="always install latest version"})
+        cmd.must_match regexify(%{version="latest"})
+      end
+
+      it "will install a of chef, unless it exists" do
+        config[:require_chef_omnibus] = true
+
+        cmd.must_match regexify(%{install_flags=""})
+        cmd.must_match regexify(%{pretty_version="install only if missing"})
+        cmd.must_match regexify(%{version="true"})
+      end
+
+      it "will pass install options, when given" do
+        config[:chef_omnibus_install_options] = "-P chefdk"
+
+        cmd.must_match regexify(%{install_flags="-P chefdk"})
+        cmd.must_match regexify(%{pretty_version="install only if missing"})
+        cmd.must_match regexify(%{version="true"})
+      end
+
+      it "will pass install options and version info, when given" do
+        config[:require_chef_omnibus] = "11"
+        config[:chef_omnibus_install_options] = "-d /tmp/place"
+
+        cmd.must_match regexify(%{install_flags="-v 11 -d /tmp/place"})
+        cmd.must_match regexify(%{pretty_version="11"})
+        cmd.must_match regexify(%{version="11"})
+      end
+
+      it "prepends sudo for sh commands when :sudo is set" do
+        config[:sudo] = true
+
+        cmd.must_match regexify(%{sudo_sh="sudo -E sh"})
+      end
 
-    it "will pass install options, when given" do
-      config[:chef_omnibus_install_options] = "-P chefdk"
+      it "does not sudo for sh commands when :sudo is falsey" do
+        config[:sudo] = false
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -P chefdk")
-      provisioner.install_command.must_match regexify(
-        "Installing Chef Omnibus (install only if missing)", :partial_line)
+        cmd.must_match regexify(%{sudo_sh="sh"})
+      end
     end
 
-    it "will pass install options and version info, when given" do
-      config[:require_chef_omnibus] = "11"
-      config[:chef_omnibus_install_options] = "-d /tmp/place"
+    describe "for powershell shells on windows os types" do
+
+      before do
+        platform.stubs(:shell_type).returns("powershell")
+        platform.stubs(:os_type).returns("windows")
+      end
+
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
+
+        cmd.lines.to_a[0..1].must_equal([
+          %{$env:http_proxy = "http://proxy"\n},
+          %{$env:HTTP_PROXY = "http://proxy"\n}
+        ])
+      end
+
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[0..1].must_equal([
+          %{$env:https_proxy = "https://proxy"\n},
+          %{$env:HTTPS_PROXY = "https://proxy"\n}
+        ])
+      end
+
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[0..3].must_equal([
+          %{$env:http_proxy = "http://proxy"\n},
+          %{$env:HTTP_PROXY = "http://proxy"\n},
+          %{$env:https_proxy = "https://proxy"\n},
+          %{$env:HTTPS_PROXY = "https://proxy"\n}
+        ])
+      end
+
+      it "returns nil if :require_chef_omnibus is falsey" do
+        config[:require_chef_omnibus] = false
+
+        cmd.must_equal nil
+      end
+
+      it "installs chef using :chef_metadata_url, if necessary" do
+        config[:chef_metadata_url] = "FROM_HERE"
+
+        cmd.must_match regexify(%{$chef_metadata_url = "FROM_HERE"})
+      end
+
+      it "sets an root path from :chef_omnibus_root" do
+        config[:chef_omnibus_root] = "\\a\\b"
+
+        cmd.must_match regexify(%{$chef_omnibus_root = "\\a\\b"})
+      end
+
+      it "sets a path for the msi pacakge based on version" do
+        config[:require_chef_omnibus] = "1.2.3"
+
+        cmd.must_match regexify(%{$msi = "$env:TEMP\\chef-1.2.3.msi"})
+      end
+
+      it "will install a specific version of chef, if necessary" do
+        config[:require_chef_omnibus] = "1.2.3"
+
+        cmd.must_match regexify(%{$pretty_version = "1.2.3"})
+        cmd.must_match regexify(%{$version = "1.2.3"})
+      end
+
+      it "will install a major/minor version of chef, if necessary" do
+        config[:require_chef_omnibus] = "11.10"
+
+        cmd.must_match regexify(%{$pretty_version = "11.10"})
+        cmd.must_match regexify(%{$version = "11.10"})
+      end
+
+      it "will install a major version of chef, if necessary" do
+        config[:require_chef_omnibus] = "12"
+
+        cmd.must_match regexify(%{$pretty_version = "12"})
+        cmd.must_match regexify(%{$version = "12"})
+      end
+
+      it "will install a downcaased version string of chef, if necessary" do
+        config[:require_chef_omnibus] = "10.1.0.RC.1"
+
+        cmd.must_match regexify(%{$pretty_version = "10.1.0.rc.1"})
+        cmd.must_match regexify(%{$version = "10.1.0.rc.1"})
+      end
+
+      it "will install the latest of chef, if necessary" do
+        config[:require_chef_omnibus] = "latest"
 
-      provisioner.install_command.must_match regexify(
-        "sudo -E sh /tmp/install.sh -v 11 -d /tmp/place")
+        cmd.must_match regexify(%{$pretty_version = "always install latest version"})
+        cmd.must_match regexify(%{$version = "latest"})
+      end
+
+      it "will install a of chef, unless it exists" do
+        config[:require_chef_omnibus] = true
+
+        cmd.must_match regexify(%{$pretty_version = "install only if missing"})
+        cmd.must_match regexify(%{$version = "true"})
+      end
     end
   end
 
   describe "#init_command" do
 
-    it "uses bourne shell" do
-      provisioner.init_command.must_match(/\Ash -c '$/)
-      provisioner.init_command.must_match(/'\Z/)
-    end
+    let(:cmd) { provisioner.init_command }
 
-    it "uses sudo for rm when configured" do
-      config[:sudo] = true
+    describe "for bourne shells" do
 
-      provisioner.init_command.
-        must_match regexify("sudo -E rm -rf ", :partial_line)
-    end
+      before { platform.stubs(:shell_type).returns("bourne") }
 
-    it "does not use sudo for rm when configured" do
-      config[:sudo] = false
+      it "uses bourne shell" do
+        cmd.must_match(/\Ash -c '$/)
+        cmd.must_match(/'\Z/)
+      end
 
-      provisioner.init_command.
-        must_match regexify("rm -rf ", :partial_line)
-      provisioner.init_command.
-        wont_match regexify("sudo -E rm -rf ", :partial_line)
-    end
+      it "ends with a single quote" do
+        cmd.must_match(/'\Z/)
+      end
+
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
+
+        cmd.lines.to_a[1..2].must_equal([
+          %{http_proxy="http://proxy"; export http_proxy\n},
+          %{HTTP_PROXY="http://proxy"; export HTTP_PROXY\n}
+        ])
+      end
+
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[1..2].must_equal([
+          %{https_proxy="https://proxy"; export https_proxy\n},
+          %{HTTPS_PROXY="https://proxy"; export HTTPS_PROXY\n}
+        ])
+      end
+
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[1..4].must_equal([
+          %{http_proxy="http://proxy"; export http_proxy\n},
+          %{HTTP_PROXY="http://proxy"; export HTTP_PROXY\n},
+          %{https_proxy="https://proxy"; export https_proxy\n},
+          %{HTTPS_PROXY="https://proxy"; export HTTPS_PROXY\n}
+        ])
+      end
+
+      it "prepends sudo for rm when :sudo is set" do
+        config[:sudo] = true
+
+        cmd.must_match regexify(%{sudo_rm="sudo -E rm"})
+      end
+
+      it "does not sudo for sh commands when :sudo is falsey" do
+        config[:sudo] = false
 
-    %w[cookbooks data data_bags environments roles clients].each do |dir|
-      it "removes the #{dir} directory" do
+        cmd.must_match regexify(%{sudo_rm="rm"})
+      end
+
+      it "sets chef component dirs for deletion" do
         config[:root_path] = "/route"
+        dirs = %W[
+          /route/clients /route/cookbooks /route/data /route/data_bags
+          /route/environments /route/roles
+        ].join(" ")
+
+        cmd.must_match regexify(%{dirs="#{dirs}"})
+      end
+
+      it "sets the root_path from :root_path" do
+        config[:root_path] = "RIGHT_HERE"
 
-        provisioner.init_command.must_match %r{rm -rf\b.*\s+/route/#{dir}\s+}
+        cmd.must_match regexify(%{root_path="RIGHT_HERE"})
       end
     end
 
-    it "creates :root_path directory" do
-      config[:root_path] = "/root/path"
+    describe "for powershell shells on windows os types" do
+
+      before do
+        platform.stubs(:shell_type).returns("powershell")
+        platform.stubs(:os_type).returns("windows")
+      end
+
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
+
+        cmd.lines.to_a[0..1].must_equal([
+          %{$env:http_proxy = "http://proxy"\n},
+          %{$env:HTTP_PROXY = "http://proxy"\n}
+        ])
+      end
+
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[0..1].must_equal([
+          %{$env:https_proxy = "https://proxy"\n},
+          %{$env:HTTPS_PROXY = "https://proxy"\n}
+        ])
+      end
+
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+
+        cmd.lines.to_a[0..3].must_equal([
+          %{$env:http_proxy = "http://proxy"\n},
+          %{$env:HTTP_PROXY = "http://proxy"\n},
+          %{$env:https_proxy = "https://proxy"\n},
+          %{$env:HTTPS_PROXY = "https://proxy"\n}
+        ])
+      end
 
-      provisioner.init_command.must_match regexify("mkdir -p /root/path")
+      it "sets chef component dirs for deletion" do
+        config[:root_path] = "\\route"
+        dirs = %W[
+          "\\route\\clients" "\\route\\cookbooks" "\\route\\data"
+          "\\route\\data_bags" "\\route\\environments" "\\route\\roles"
+        ].join(", ")
+
+        cmd.must_match regexify(%{$dirs = @(#{dirs})})
+      end
+
+      it "sets the root_path from :root_path" do
+        config[:root_path] = "RIGHT_HERE"
+
+        cmd.must_match regexify(%{$root_path = "RIGHT_HERE"})
+      end
     end
   end