test-kitchen 1.3.1 → 1.4.0.beta.1

data/spec/kitchen/configurable_spec.rb

@@ -19,6 +19,7 @@
 require_relative "../spec_helper"
 require "stringio"
 
+require "kitchen"
 require "kitchen/errors"
 require "kitchen/configurable"
 
@@ -30,8 +31,11 @@ module Kitchen
 
       include Kitchen::Configurable
 
+      attr_reader :instance
+
       def initialize(config = {})
         init_config(config)
+        @instance = config[:instance]
       end
     end
 
@@ -44,6 +48,7 @@ module Kitchen
       default_config :edible, true
       default_config :fetch_command, "curl"
       default_config :success_path, "./success"
+      default_config :bunch_of_paths, %W[./a ./b ./c]
       default_config :beans_url do |subject|
         "http://gim.me/#{subject[:beans]}"
       end
@@ -61,6 +66,7 @@ module Kitchen
       end
 
       expand_path_for :success_path
+      expand_path_for :bunch_of_paths
       expand_path_for :relative_path, false
       expand_path_for :another_path
       expand_path_for :complex_path do |subject|
@@ -90,7 +96,10 @@ end
 describe Kitchen::Configurable do
 
   let(:config)    { Hash.new }
-  let(:instance)  { stub(:name => "coolbeans", :to_str => "<instance>") }
+  let(:platform)  { stub }
+  let(:instance) do
+    stub(:name => "coolbeans", :to_str => "<instance>", :platform => platform)
+  end
 
   let(:subject) do
     Kitchen::Thing::Tiny.new(config).finalize_config!(instance)
@@ -312,6 +321,12 @@ describe Kitchen::Configurable do
         subject[:success_path].must_equal "/the/other/one"
       end
 
+      it "expands all items if path is an array" do
+        subject[:bunch_of_paths].must_equal %W[
+          /tmp/yo/self/a /tmp/yo/self/b /tmp/yo/self/c
+        ]
+      end
+
       it "doesn't expand path with a falsy expand_path_for value" do
         config[:relative_path] = "./rel"
 
@@ -354,6 +369,10 @@ describe Kitchen::Configurable do
     end
   end
 
+  it "#name returns the name of the plugin" do
+    subject.name.must_equal "Tiny"
+  end
+
   describe "#diagnose" do
 
     it "returns an empty hash for no config" do
@@ -487,4 +506,311 @@ describe Kitchen::Configurable do
       end
     end
   end
+
+  describe "#remote_path_join" do
+
+    it "returns unix style path separators for unix os_type" do
+      platform.stubs(:os_type).returns("unix")
+
+      subject.remote_path_join("a", "b", "c").must_equal "a/b/c"
+    end
+
+    it "returns windows style path separators for windows os_type" do
+      platform.stubs(:os_type).returns("windows")
+
+      subject.remote_path_join("a", "b", "c").must_equal "a\\b\\c"
+    end
+
+    it "accepts combinations of strings and arrays" do
+      platform.stubs(:os_type).returns("unix")
+
+      subject.remote_path_join(%W[a b], "c", %W[d e]).must_equal "a/b/c/d/e"
+    end
+
+    it "accepts a single array" do
+      platform.stubs(:os_type).returns("windows")
+
+      subject.remote_path_join(%W[a b]).must_equal "a\\b"
+    end
+
+    it "converts all windows path separators to unix for unix os_type" do
+      platform.stubs(:os_type).returns("unix")
+
+      subject.remote_path_join("\\a\\b", "c/d").must_equal "/a/b/c/d"
+    end
+
+    it "converts all unix path separators to windows for windows os_type" do
+      platform.stubs(:os_type).returns("windows")
+
+      subject.remote_path_join("/a/b", "c\\d").must_equal "\\a\\b\\c\\d"
+    end
+  end
+
+  describe "#windows_os?" do
+
+    it "for windows type platform returns true" do
+      platform.stubs(:os_type).returns("windows")
+
+      subject.windows_os?.must_equal true
+    end
+
+    it "for unix type platform returns false" do
+      platform.stubs(:os_type).returns("unix")
+
+      subject.windows_os?.must_equal false
+    end
+
+    it "for newfangled type platform return false" do
+      platform.stubs(:os_type).returns("internet_cat")
+
+      subject.windows_os?.must_equal false
+    end
+
+    it "for unset type platform returns false" do
+      platform.stubs(:os_type).returns(nil)
+
+      subject.windows_os?.must_equal false
+    end
+  end
+
+  describe "#unix_os?" do
+
+    it "for windows type platform returns false" do
+      platform.stubs(:os_type).returns("windows")
+
+      subject.unix_os?.must_equal false
+    end
+
+    it "for unix type platform returns true" do
+      platform.stubs(:os_type).returns("unix")
+
+      subject.unix_os?.must_equal true
+    end
+
+    it "for newfangled type platform return false" do
+      platform.stubs(:os_type).returns("internet_cat")
+
+      subject.unix_os?.must_equal false
+    end
+
+    it "for unset type platform returns true" do
+      platform.stubs(:os_type).returns(nil)
+
+      subject.unix_os?.must_equal true
+    end
+  end
+
+  describe "#powershell_shell?" do
+
+    it "for powershell type shell returns true" do
+      platform.stubs(:shell_type).returns("powershell")
+
+      subject.powershell_shell?.must_equal true
+    end
+
+    it "for bourne type shell returns false" do
+      platform.stubs(:shell_type).returns("bourne")
+
+      subject.powershell_shell?.must_equal false
+    end
+
+    it "for newfangled type shell return false" do
+      platform.stubs(:shell_type).returns("internet_cat")
+
+      subject.powershell_shell?.must_equal false
+    end
+
+    it "for unset type shell returns false" do
+      platform.stubs(:shell_type).returns(nil)
+
+      subject.powershell_shell?.must_equal false
+    end
+  end
+
+  describe "#bourne_shell?" do
+
+    it "for powershell type shell returns false" do
+      platform.stubs(:shell_type).returns("powershell")
+
+      subject.bourne_shell?.must_equal false
+    end
+
+    it "for bourne type shell returns true" do
+      platform.stubs(:shell_type).returns("bourne")
+
+      subject.bourne_shell?.must_equal true
+    end
+
+    it "for newfangled type shell return false" do
+      platform.stubs(:shell_type).returns("internet_cat")
+
+      subject.bourne_shell?.must_equal false
+    end
+
+    it "for unset type shell returns true" do
+      platform.stubs(:shell_type).returns(nil)
+
+      subject.bourne_shell?.must_equal true
+    end
+  end
+
+  describe "#shell_env_var" do
+
+    it "for powershell type shells returns a powershell environment variable" do
+      platform.stubs(:shell_type).returns("powershell")
+
+      subject.send(:shell_env_var, "foo", "bar").
+        must_equal %{$env:foo = "bar"}
+    end
+
+    it "for bourne type shells returns a bourne environment variable" do
+      platform.stubs(:shell_type).returns("bourne")
+
+      subject.send(:shell_env_var, "foo", "bar").
+        must_equal %{foo="bar"; export foo}
+    end
+  end
+
+  describe "#shell_var" do
+
+    it "for powershell type shells returns a powershell variable" do
+      platform.stubs(:shell_type).returns("powershell")
+
+      subject.send(:shell_var, "foo", "bar").must_equal %{$foo = "bar"}
+    end
+
+    it "for bourne type shells returns a bourne variable" do
+      platform.stubs(:shell_type).returns("bourne")
+
+      subject.send(:shell_var, "foo", "bar").must_equal %{foo="bar"}
+    end
+  end
+
+  describe "#wrap_shell_code" do
+
+    let(:cmd) { subject.send(:wrap_shell_code, "mkdir foo") }
+
+    describe "for bourne shells" do
+
+      before { platform.stubs(:shell_type).returns("bourne") }
+
+      it "uses bourne shell (sh)" do
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          sh -c '
+
+          mkdir foo
+          '
+        CODE
+      end
+
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          sh -c '
+          http_proxy="http://proxy"; export http_proxy
+          HTTP_PROXY="http://proxy"; export HTTP_PROXY
+          mkdir foo
+          '
+        CODE
+      end
+
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          sh -c '
+          https_proxy="https://proxy"; export https_proxy
+          HTTPS_PROXY="https://proxy"; export HTTPS_PROXY
+          mkdir foo
+          '
+        CODE
+      end
+
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          sh -c '
+          http_proxy="http://proxy"; export http_proxy
+          HTTP_PROXY="http://proxy"; export HTTP_PROXY
+          https_proxy="https://proxy"; export https_proxy
+          HTTPS_PROXY="https://proxy"; export HTTPS_PROXY
+          mkdir foo
+          '
+        CODE
+      end
+    end
+
+    describe "for powershell shells" do
+
+      before { platform.stubs(:shell_type).returns("powershell") }
+
+      it "uses powershell shell" do
+        cmd.must_equal("\nmkdir foo")
+      end
+
+      it "exports http_proxy & HTTP_PROXY when :http_proxy is set" do
+        config[:http_proxy] = "http://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          $env:http_proxy = "http://proxy"
+          $env:HTTP_PROXY = "http://proxy"
+          mkdir foo
+        CODE
+      end
+
+      it "exports https_proxy & HTTPS_PROXY when :https_proxy is set" do
+        config[:https_proxy] = "https://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          $env:https_proxy = "https://proxy"
+          $env:HTTPS_PROXY = "https://proxy"
+          mkdir foo
+        CODE
+      end
+
+      it "exports all http proxy variables when both are set" do
+        config[:http_proxy] = "http://proxy"
+        config[:https_proxy] = "https://proxy"
+
+        cmd.must_equal(outdent!(<<-CODE.chomp))
+          $env:http_proxy = "http://proxy"
+          $env:HTTP_PROXY = "http://proxy"
+          $env:https_proxy = "https://proxy"
+          $env:HTTPS_PROXY = "https://proxy"
+          mkdir foo
+        CODE
+      end
+    end
+  end
+
+  it "has a default verify dependencies method" do
+    subject.verify_dependencies.must_be_nil
+  end
+
+  describe "#logger" do
+
+    before  { @klog = Kitchen.logger }
+    after   { Kitchen.logger = @klog }
+
+    it "returns the instance's logger" do
+      logger = stub("logger")
+      instance = stub(:logger => logger)
+      subject = Kitchen::Thing::Tiny.new(config.merge(:instance => instance))
+      subject.send(:logger).must_equal logger
+    end
+
+    it "returns the default logger if instance's logger is not set" do
+      subject = Kitchen::Thing::Tiny.new(config)
+      Kitchen.logger = "yep"
+
+      subject.send(:logger).must_equal Kitchen.logger
+    end
+  end
+
+  def outdent!(*args)
+    Kitchen::Util.outdent!(*args)
+  end
 end

data/spec/kitchen/data_munger_spec.rb

@@ -89,7 +89,8 @@ module Kitchen
     DATA_KEYS = {
       :driver => :name,
       :provisioner => :name,
-      :busser => :version
+      :transport => :name,
+      :verifier => :name
     }
 
     DATA_KEYS.each_pair do |key, default_key|
@@ -127,6 +128,19 @@ module Kitchen
             )
           end
 
+          it "returns kitchen config #{key} name from callable" do
+            DataMunger.new(
+              {},
+              {
+                :defaults => {
+                  key => ->(suite, platform) { "#{suite}++#{platform}" }
+                }
+              }
+            ).public_send("#{key}_data_for", "suite", "platform").must_equal(
+              default_key => "suite++platform"
+            )
+          end
+
           it "returns common #{key} name" do
             DataMunger.new(
               {
@@ -1049,12 +1063,12 @@ module Kitchen
             end
           end
 
-          describe "for #busser_data_for" do
+          describe "for #verifier_data_for" do
 
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :busser => "chefy",
+                  :verifier => "chefy",
                   :platforms => [
                     { :name => "plat" }
                   ],
@@ -1065,8 +1079,8 @@ module Kitchen
                 {
                   key => "datvalue"
                 }
-              ).busser_data_for("sweet", "plat").must_equal(
-                :version => "chefy",
+              ).verifier_data_for("sweet", "plat").must_equal(
+                :name => "chefy",
                 key => "datvalue"
               )
             end
@@ -1077,7 +1091,7 @@ module Kitchen
                   :kitchen => {
                     key => "datvalue"
                   },
-                  :busser => "chefy",
+                  :verifier => "chefy",
                   :platforms => [
                     { :name => "plat" }
                   ],
@@ -1086,8 +1100,8 @@ module Kitchen
                   ]
                 },
                 {}
-              ).busser_data_for("sweet", "plat").must_equal(
-                :version => "chefy",
+              ).verifier_data_for("sweet", "plat").must_equal(
+                :name => "chefy",
                 key => "datvalue"
               )
             end
@@ -1098,7 +1112,7 @@ module Kitchen
                   :kitchen => {
                     key => "datvalue"
                   },
-                  :busser => "chefy",
+                  :verifier => "chefy",
                   :platforms => [
                     { :name => "plat" }
                   ],
@@ -1109,16 +1123,16 @@ module Kitchen
                 {
                   key => "ilose"
                 }
-              ).busser_data_for("sweet", "plat").must_equal(
-                :version => "chefy",
+              ).verifier_data_for("sweet", "plat").must_equal(
+                :name => "chefy",
                 key => "datvalue"
               )
             end
 
-            it "rejects any value in busser data" do
+            it "rejects any value in verifier data" do
               DataMunger.new(
                 {
-                  :busser => {
+                  :verifier => {
                     :version => "chefy",
                     key => "imevil"
                   },
@@ -1130,11 +1144,98 @@ module Kitchen
                   ]
                 },
                 {}
-              ).busser_data_for("sweet", "plat").must_equal(
+              ).verifier_data_for("sweet", "plat").must_equal(
                 :version => "chefy"
               )
             end
           end
+
+          describe "for #transport_data_for" do
+
+            it "is returned when provided" do
+              DataMunger.new(
+                {
+                  :transport => "pipes",
+                  :platforms => [
+                    { :name => "plat" }
+                  ],
+                  :suites => [
+                    { :name => "sweet" }
+                  ]
+                },
+                {
+                  key => "datvalue"
+                }
+              ).transport_data_for("sweet", "plat").must_equal(
+                :name => "pipes",
+                key => "datvalue"
+              )
+            end
+
+            it "is returned when provided in user data" do
+              DataMunger.new(
+                {
+                  :kitchen => {
+                    key => "datvalue"
+                  },
+                  :transport => "pipes",
+                  :platforms => [
+                    { :name => "plat" }
+                  ],
+                  :suites => [
+                    { :name => "sweet" }
+                  ]
+                },
+                {}
+              ).transport_data_for("sweet", "plat").must_equal(
+                :name => "pipes",
+                key => "datvalue"
+              )
+            end
+
+            it "user data value beats provided value" do
+              DataMunger.new(
+                {
+                  :kitchen => {
+                    key => "datvalue"
+                  },
+                  :transport => "pipes",
+                  :platforms => [
+                    { :name => "plat" }
+                  ],
+                  :suites => [
+                    { :name => "sweet" }
+                  ]
+                },
+                {
+                  key => "ilose"
+                }
+              ).transport_data_for("sweet", "plat").must_equal(
+                :name => "pipes",
+                key => "datvalue"
+              )
+            end
+
+            it "rejects any value in transport data" do
+              DataMunger.new(
+                {
+                  :transport => {
+                    :name => "pipes",
+                    key => "imevil"
+                  },
+                  :platforms => [
+                    { :name => "plat" }
+                  ],
+                  :suites => [
+                    { :name => "sweet" }
+                  ]
+                },
+                {}
+              ).transport_data_for("sweet", "plat").must_equal(
+                :name => "pipes"
+              )
+            end
+          end
         end
       end
     end
@@ -1616,5 +1717,667 @@ module Kitchen
         end
       end
     end
+
+    describe "legacy http_proxy & https_proxy from driver" do
+
+      describe "from a single source" do
+
+        it "common driver value remains in driver" do
+          DataMunger.new(
+            {
+              :provisioner => "chefy",
+              :driver => {
+                :name => "starship",
+                :http_proxy => "http://proxy",
+                :https_proxy => "https://proxy"
+              }
+            },
+            {}
+          ).driver_data_for("suite", "platform").must_equal(
+            :name => "starship",
+            :http_proxy => "http://proxy",
+            :https_proxy => "https://proxy"
+          )
+        end
+
+        it "common driver value copies into provisioner" do
+          DataMunger.new(
+            {
+              :provisioner => "chefy",
+              :driver => {
+                :name => "starship",
+                :http_proxy => "http://proxy",
+                :https_proxy => "https://proxy"
+              }
+            },
+            {}
+          ).provisioner_data_for("suite", "platform").must_equal(
+            :name => "chefy",
+            :http_proxy => "http://proxy",
+            :https_proxy => "https://proxy"
+          )
+        end
+
+        it "common driver value copies into verifier" do
+          DataMunger.new(
+            {
+              :verifier => "bussy",
+              :driver => {
+                :name => "starship",
+                :http_proxy => "http://proxy",
+                :https_proxy => "https://proxy"
+              }
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "bussy",
+            :http_proxy => "http://proxy",
+            :https_proxy => "https://proxy"
+          )
+        end
+
+        it "common driver value loses to existing provisioner value" do
+          DataMunger.new(
+            {
+              :provisioner => {
+                :name => "chefy",
+                :http_proxy => "it's probably fine",
+                :https_proxy => "la quinta"
+              },
+              :driver => {
+                :name => "starship",
+                :http_proxy => "dragons",
+                :https_proxy => "cats"
+              }
+            },
+            {}
+          ).provisioner_data_for("suite", "platform").must_equal(
+            :name => "chefy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "common driver value loses to existing verifier value" do
+          DataMunger.new(
+            {
+              :verifier => {
+                :name => "bussy",
+                :http_proxy => "it's probably fine",
+                :https_proxy => "la quinta"
+              },
+              :driver => {
+                :name => "starship",
+                :http_proxy => "dragons",
+                :https_proxy => "cats"
+              }
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "bussy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "suite driver value remains in driver" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :provisioner => "chefy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).driver_data_for("sweet", "platform").must_equal(
+            :name => "starship",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "suite driver value copies into provisioner" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :provisioner => "chefy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).provisioner_data_for("sweet", "platform").must_equal(
+            :name => "chefy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "suite driver value copies into verifier" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :verifier => "bussy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "platform").must_equal(
+            :name => "bussy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "suite driver value loses to existing provisioner value" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :provisioner => {
+                    :name => "chefy",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  },
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "dragons",
+                    :https_proxy => "cats"
+                  }
+                }
+              ]
+            },
+            {}
+          ).provisioner_data_for("sweet", "platform").must_equal(
+            :name => "chefy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "suite driver value loses to existing verifier value" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :verifier => {
+                    :name => "bussy",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  },
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "dragons",
+                    :https_proxy => "cats"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "platform").must_equal(
+            :name => "bussy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "platform driver value remains in driver" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :provisioner => "chefy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).driver_data_for("suite", "plat").must_equal(
+            :name => "starship",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "platform driver value copies into provisioner" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :provisioner => "chefy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).provisioner_data_for("suite", "plat").must_equal(
+            :name => "chefy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "platform driver value copies into verifier" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :verifier => "bussy",
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("suite", "plat").must_equal(
+            :name => "bussy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "platform driver value loses to existing provisioner value" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :provisioner => {
+                    :name => "chefy",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  },
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "dragons",
+                    :https_proxy => "cats"
+                  }
+                }
+              ]
+            },
+            {}
+          ).provisioner_data_for("suite", "plat").must_equal(
+            :name => "chefy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+
+        it "platform driver value loses to existing verifier value" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :verifier => {
+                    :name => "bussy",
+                    :http_proxy => "it's probably fine",
+                    :https_proxy => "la quinta"
+                  },
+                  :driver => {
+                    :name => "starship",
+                    :http_proxy => "dragons",
+                    :https_proxy => "cats"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("suite", "plat").must_equal(
+            :name => "bussy",
+            :http_proxy => "it's probably fine",
+            :https_proxy => "la quinta"
+          )
+        end
+      end
+    end
+
+    describe "legacy busser blocks to verifier" do
+
+      describe "from a single source" do
+
+        it "merges old common busser name to version into verifier" do
+          DataMunger.new(
+            {
+              :busser => "starship"
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "busser",
+            :version => "starship"
+          )
+        end
+
+        it "merges old common busser name to version with exising verifier" do
+          DataMunger.new(
+            {
+              :busser => "starship",
+              :verifier => {
+                :a => "b"
+              }
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "busser",
+            :version => "starship",
+            :a => "b"
+          )
+        end
+
+        it "merges old common busser name to version into verifier with name" do
+          DataMunger.new(
+            {
+              :busser => "starship",
+              :verifier => "stellar"
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "stellar",
+            :version => "starship"
+          )
+        end
+
+        it "merges old busser data into verifier with name" do
+          DataMunger.new(
+            {
+              :busser => {
+                :a => "b"
+              },
+              :verifier => "stellar"
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "stellar",
+            :a => "b"
+          )
+        end
+
+        it "merges old busser data into verifier data" do
+          DataMunger.new(
+            {
+              :busser => {
+                :a => "b",
+                :both => "legacy"
+              },
+              :verifier => {
+                :name => "stellar",
+                :c => "d",
+                :both => "modern"
+              }
+            },
+            {}
+          ).verifier_data_for("suite", "platform").must_equal(
+            :name => "stellar",
+            :a => "b",
+            :c => "d",
+            :both => "modern"
+          )
+        end
+
+        it "returns platform verifier name" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :busser => "flip"
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("suite", "plat").must_equal(
+            :name => "busser",
+            :version => "flip"
+          )
+        end
+
+        it "return platform config containing verifier hash" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :busser => "flip",
+                  :verifier => {
+                    :flop => "yep"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("suite", "plat").must_equal(
+            :name => "busser",
+            :version => "flip",
+            :flop => "yep"
+          )
+        end
+
+        it "returns suite driver name" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :busser => "waz"
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "platform").must_equal(
+            :name => "busser",
+            :version => "waz"
+          )
+        end
+
+        it "returns suite config containing verifier hash" do
+          DataMunger.new(
+            {
+              :suites => [
+                {
+                  :name => "sweet",
+                  :busser => "waz",
+                  :verifier => {
+                    :up => "nope"
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "platform").must_equal(
+            :name => "busser",
+            :version => "waz",
+            :up => "nope"
+          )
+        end
+      end
+
+      describe "from multiple sources" do
+
+        it "suite into platform into common" do
+          DataMunger.new(
+            {
+              :busser => {
+                :version => "commony",
+                :color => "purple",
+                :fruit => %w[apple pear],
+                :deep => { :common => "junk" }
+              },
+              :platforms => [
+                {
+                  :name => "plat",
+                  :busser => {
+                    :version => "platformy",
+                    :fruit => ["banana"],
+                    :deep => { :platform => "stuff" }
+                  }
+                }
+              ],
+              :suites => [
+                {
+                  :name => "sweet",
+                  :busser => {
+                    :version => "suitey",
+                    :vehicle => "car",
+                    :deep => { :suite => "things" }
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "plat").must_equal(
+            :name => "busser",
+            :version => "suitey",
+            :color => "purple",
+            :fruit => ["banana"],
+            :vehicle => "car",
+            :deep => {
+              :common => "junk",
+              :platform => "stuff",
+              :suite => "things"
+            }
+          )
+        end
+
+        it "platform into common" do
+          DataMunger.new(
+            {
+              :busser => {
+                :version => "commony",
+                :color => "purple",
+                :fruit => %w[apple pear],
+                :deep => { :common => "junk" }
+              },
+              :platforms => [
+                {
+                  :name => "plat",
+                  :busser => {
+                    :version => "platformy",
+                    :fruit => ["banana"],
+                    :deep => { :platform => "stuff" }
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "plat").must_equal(
+            :name => "busser",
+            :version => "platformy",
+            :color => "purple",
+            :fruit => ["banana"],
+            :deep => {
+              :common => "junk",
+              :platform => "stuff"
+            }
+          )
+        end
+
+        it "suite into common" do
+          DataMunger.new(
+            {
+              :busser => {
+                :version => "commony",
+                :color => "purple",
+                :fruit => %w[apple pear],
+                :deep => { :common => "junk" }
+              },
+              :suites => [
+                {
+                  :name => "sweet",
+                  :busser => {
+                    :version => "suitey",
+                    :vehicle => "car",
+                    :deep => { :suite => "things" }
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "plat").must_equal(
+            :name => "busser",
+            :version => "suitey",
+            :color => "purple",
+            :fruit => %w[apple pear],
+            :vehicle => "car",
+            :deep => {
+              :common => "junk",
+              :suite => "things"
+            }
+          )
+        end
+
+        it "suite into platform" do
+          DataMunger.new(
+            {
+              :platforms => [
+                {
+                  :name => "plat",
+                  :busser => {
+                    :version => "platformy",
+                    :fruit => ["banana"],
+                    :deep => { :platform => "stuff" }
+                  }
+                }
+              ],
+              :suites => [
+                {
+                  :name => "sweet",
+                  :busser => {
+                    :version => "suitey",
+                    :vehicle => "car",
+                    :deep => { :suite => "things" }
+                  }
+                }
+              ]
+            },
+            {}
+          ).verifier_data_for("sweet", "plat").must_equal(
+            :name => "busser",
+            :version => "suitey",
+            :fruit => ["banana"],
+            :vehicle => "car",
+            :deep => {
+              :platform => "stuff",
+              :suite => "things"
+            }
+          )
+        end
+      end
+    end
   end
 end