test-kitchen 1.14.1 → 1.14.2

data/spec/kitchen/configurable_spec.rb

@@ -24,11 +24,8 @@ require "kitchen/errors"
 require "kitchen/configurable"
 
 module Kitchen
-
   module Thing
-
     class Tiny
-
       include Kitchen::Configurable
 
       attr_reader :instance
@@ -40,12 +37,10 @@ module Kitchen
     end
 
     class Versioned < Tiny
-
       plugin_version "1.8.17"
     end
 
     class StaticDefaults
-
       include Kitchen::Configurable
 
       default_config :beans, "kidney"
@@ -53,7 +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 :bunch_of_paths, %w{./a ./b ./c}
       default_config :beans_url do |subject|
         "http://gim.me/#{subject[:beans]}"
       end
@@ -84,7 +79,6 @@ module Kitchen
     end
 
     class SubclassDefaults < StaticDefaults
-
       default_config :yea, "ya"
       default_config :fetch_command, "wget"
       default_config :fetch_url, "http://no.beans"
@@ -99,11 +93,10 @@ module Kitchen
 end
 
 describe Kitchen::Configurable do
-
   let(:config)    { Hash.new }
   let(:platform)  { stub }
   let(:instance) do
-    stub(:name => "coolbeans", :to_str => "<instance>", :platform => platform)
+    stub(name: "coolbeans", to_str: "<instance>", platform: platform)
   end
 
   let(:subject) do
@@ -111,14 +104,13 @@ describe Kitchen::Configurable do
   end
 
   describe "creation and setup" do
-
     it "#instance returns its instance" do
       subject.instance.must_equal instance
     end
 
     it "#finalize_config! raises ClientError if instance is nil" do
-      proc { Kitchen::Thing::Tiny.new({}).finalize_config!(nil) }.
-        must_raise(Kitchen::ClientError)
+      proc { Kitchen::Thing::Tiny.new({}).finalize_config!(nil) }
+        .must_raise(Kitchen::ClientError)
     end
 
     it "#finalize_config! returns self for chaining" do
@@ -128,22 +120,19 @@ describe Kitchen::Configurable do
   end
 
   describe "configuration" do
-
     describe "provided from the outside" do
-
       it "returns provided config" do
-        config[:fruit] = %w[apples oranges]
+        config[:fruit] = %w{apples oranges}
         config[:cool_enough] = true
 
-        subject[:fruit].must_equal %w[apples oranges]
+        subject[:fruit].must_equal %w{apples oranges}
         subject[:cool_enough].must_equal true
       end
     end
 
     describe "using static default_config statements" do
-
       let(:config) do
-        { :need_it => true, :a_default => true }
+        { need_it: true, a_default: true }
       end
 
       let(:subject) do
@@ -183,9 +172,8 @@ describe Kitchen::Configurable do
     end
 
     describe "using inherited static default_config statements" do
-
       let(:config) do
-        { :need_it => true, :a_default => "please" }
+        { need_it: true, a_default: "please" }
       end
 
       let(:subject) do
@@ -216,9 +204,8 @@ describe Kitchen::Configurable do
     end
 
     describe "using static required_config statements" do
-
       let(:config) do
-        { :a_default => true }
+        { a_default: true }
       end
 
       let(:subject) do
@@ -269,7 +256,6 @@ describe Kitchen::Configurable do
     end
 
     describe "using inherited static require_config statements" do
-
       let(:subject) do
         Kitchen::Thing::SubclassDefaults.new(config).finalize_config!(instance)
       end
@@ -301,9 +287,8 @@ describe Kitchen::Configurable do
     end
 
     describe "using static expand_path_for statements" do
-
       let(:config) do
-        { :need_it => "a", :a_default => "b", :kitchen_root => "/tmp/yo/self" }
+        { need_it: "a", a_default: "b", kitchen_root: "/tmp/yo/self" }
       end
 
       let(:subject) do
@@ -327,9 +312,9 @@ describe Kitchen::Configurable do
       end
 
       it "expands all items if path is an array" do
-        paths = %W[
+        paths = %w{
           /tmp/yo/self/a /tmp/yo/self/b /tmp/yo/self/c
-        ]
+        }
         os_safe_paths = paths.collect { |path| os_safe_root_path(path) }
         subject[:bunch_of_paths].must_equal os_safe_paths
       end
@@ -361,9 +346,8 @@ describe Kitchen::Configurable do
     end
 
     describe "using inherited static expand_path_for statements" do
-
       let(:config) do
-        { :need_it => "a", :a_default => "please", :kitchen_root => "/rooty" }
+        { need_it: "a", a_default: "please", kitchen_root: "/rooty" }
       end
 
       let(:subject) do
@@ -382,7 +366,7 @@ describe Kitchen::Configurable do
     end
 
     it "#config_keys returns an array of config key names" do
-      subject = Kitchen::Thing::Tiny.new(:ice_cream => "dragon")
+      subject = Kitchen::Thing::Tiny.new(ice_cream: "dragon")
 
       subject.config_keys.sort.must_equal [:ice_cream]
     end
@@ -393,14 +377,13 @@ describe Kitchen::Configurable do
   end
 
   describe "#diagnose" do
-
     it "returns an empty hash for no config" do
       subject.diagnose.must_equal Hash.new
     end
 
     it "returns a hash of config" do
       config[:alpha] = "beta"
-      subject.diagnose.must_equal(:alpha => "beta")
+      subject.diagnose.must_equal(alpha: "beta")
     end
 
     it "returns a hash with sorted keys" do
@@ -412,35 +395,33 @@ describe Kitchen::Configurable do
   end
 
   describe "#diagnose_plugin" do
-
     it "returns a plugin hash for a plugin without version" do
       subject.diagnose_plugin.must_equal(
-        :name => "Tiny", :class => "Kitchen::Thing::Tiny",
-        :version => nil, :api_version => nil
+        name: "Tiny", class: "Kitchen::Thing::Tiny",
+        version: nil, api_version: nil
       )
     end
 
     it "returns a plugin hash for a plugin with version" do
       subject = Kitchen::Thing::Versioned.new(config).finalize_config!(instance)
       subject.diagnose_plugin.must_equal(
-        :name => "Versioned", :class => "Kitchen::Thing::Versioned",
-        :version => "1.8.17", :api_version => nil
+        name: "Versioned", class: "Kitchen::Thing::Versioned",
+        version: "1.8.17", api_version: nil
       )
     end
   end
 
   describe "#calculate_path" do
-
     let(:config) do
-      { :test_base_path => "/the/basest" }
+      { test_base_path: "/the/basest" }
     end
 
     let(:suite) do
-      stub(:name => "ultimate")
+      stub(name: "ultimate")
     end
 
     let(:instance) do
-      stub(:name => "coolbeans", :to_str => "<instance>", :suite => suite)
+      stub(name: "coolbeans", to_str: "<instance>", suite: suite)
     end
 
     let(:subject) do
@@ -457,7 +438,6 @@ describe Kitchen::Configurable do
     end
 
     describe "for directories" do
-
       before do
         FileUtils.mkdir_p(File.join(Dir.pwd, "winner"))
         FileUtils.mkdir_p("/the/basest/winner")
@@ -465,8 +445,8 @@ describe Kitchen::Configurable do
       end
 
       it "prefers a path containing base path and suite name if it exists" do
-        subject.calculate_path("winner").
-          must_equal "/the/basest/ultimate/winner"
+        subject.calculate_path("winner")
+               .must_equal "/the/basest/ultimate/winner"
       end
 
       it "prefers a path containing base path if it exists" do
@@ -492,13 +472,12 @@ describe Kitchen::Configurable do
       it "uses a custom base path" do
         FileUtils.mkdir_p("/custom/ultimate/winner")
 
-        subject.calculate_path("winner", :base_path => "/custom").
-          must_equal "/custom/ultimate/winner"
+        subject.calculate_path("winner", base_path: "/custom")
+               .must_equal "/custom/ultimate/winner"
       end
     end
 
     describe "for files" do
-
       before do
         FileUtils.mkdir_p(Dir.pwd)
         FileUtils.touch(File.join(Dir.pwd, "winner"))
@@ -509,15 +488,15 @@ describe Kitchen::Configurable do
       end
 
       it "prefers a path containing base path and suite name if it exists" do
-        subject.calculate_path("winner", :type => :file).
-          must_equal "/the/basest/ultimate/winner"
+        subject.calculate_path("winner", type: :file)
+               .must_equal "/the/basest/ultimate/winner"
       end
 
       it "prefers a path containing base path if it exists" do
         FileUtils.rm_rf("/the/basest/ultimate/winner")
 
-        subject.calculate_path("winner", :type => :file).
-          must_equal "/the/basest/winner"
+        subject.calculate_path("winner", type: :file)
+               .must_equal "/the/basest/winner"
       end
 
       it "prefers a path in the current working directory if it exists" do
@@ -525,7 +504,7 @@ describe Kitchen::Configurable do
         FileUtils.rm_rf("/the/basest/winner")
         pwd_dir = File.join(Dir.pwd, "winner")
 
-        subject.calculate_path("winner", :type => :file).must_equal pwd_dir
+        subject.calculate_path("winner", type: :file).must_equal pwd_dir
       end
 
       it "raises a UserError if test_base_path key is not set" do
@@ -538,14 +517,13 @@ describe Kitchen::Configurable do
         FileUtils.mkdir_p("/custom/ultimate")
         FileUtils.touch(File.join("/custom/ultimate", "winner"))
 
-        subject.calculate_path("winner", :type => :file, :base_path => "/custom").
-          must_equal "/custom/ultimate/winner"
+        subject.calculate_path("winner", type: :file, base_path: "/custom")
+               .must_equal "/custom/ultimate/winner"
       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")
 
@@ -555,36 +533,35 @@ describe Kitchen::Configurable do
     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"
+      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"
+      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"
+      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"
+      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"
+      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")
 
@@ -611,7 +588,6 @@ describe Kitchen::Configurable do
   end
 
   describe "#unix_os?" do
-
     it "for windows type platform returns false" do
       platform.stubs(:os_type).returns("windows")
 
@@ -638,7 +614,6 @@ describe Kitchen::Configurable do
   end
 
   describe "#powershell_shell?" do
-
     it "for powershell type shell returns true" do
       platform.stubs(:shell_type).returns("powershell")
 
@@ -665,7 +640,6 @@ describe Kitchen::Configurable do
   end
 
   describe "#bourne_shell?" do
-
     it "for powershell type shell returns false" do
       platform.stubs(:shell_type).returns("powershell")
 
@@ -692,24 +666,22 @@ describe Kitchen::Configurable do
   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"}
+      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}
+      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")
 
@@ -724,7 +696,6 @@ describe Kitchen::Configurable do
   end
 
   describe "#wrap_shell_code" do
-
     let(:cmd) { subject.send(:wrap_shell_code, "mkdir foo") }
 
     before do
@@ -742,7 +713,6 @@ describe Kitchen::Configurable do
     end
 
     describe "for bourne shells" do
-
       before { platform.stubs(:shell_type).returns("bourne") }
 
       it "uses bourne shell (sh)" do
@@ -959,7 +929,6 @@ describe Kitchen::Configurable do
     end
 
     describe "for powershell shells" do
-
       before { platform.stubs(:shell_type).returns("powershell") }
 
       it "uses powershell shell" do
@@ -1117,14 +1086,13 @@ describe Kitchen::Configurable do
   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))
+      instance = stub(logger: logger)
+      subject = Kitchen::Thing::Tiny.new(config.merge(instance: instance))
       subject.send(:logger).must_equal logger
     end
 

data/spec/kitchen/data_munger_spec.rb

@@ -21,33 +21,30 @@ require_relative "../spec_helper"
 require "kitchen/data_munger"
 
 module Kitchen # rubocop:disable Metrics/ModuleLength
-
   describe DataMunger do
-
     describe "#platform_data" do
-
       it "returns an array of platform data" do
         DataMunger.new(
-          :platforms => [
+          platforms: [
             {
-              :name => "one",
-              :stuff => "junk"
+              name: "one",
+              stuff: "junk",
             },
             {
-              :name => "two",
-              :misc => "things"
-            }
+              name: "two",
+              misc: "things",
+            },
           ]
         ).platform_data.must_equal([
-          {
-            :name => "one",
-            :stuff => "junk"
-          },
-          {
-            :name => "two",
-            :misc => "things"
-          }
-        ])
+                                     {
+                                       name: "one",
+                                       stuff: "junk",
+                                     },
+                                     {
+                                       name: "two",
+                                       misc: "things",
+                                     },
+                                   ])
       end
 
       it "returns an empty array if platforms is not defined" do
@@ -56,29 +53,28 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     describe "#suite_data" do
-
       it "returns an array of suite data" do
         DataMunger.new(
-          :suites => [
+          suites: [
             {
-              :name => "one",
-              :stuff => "junk"
+              name: "one",
+              stuff: "junk",
             },
             {
-              :name => "two",
-              :misc => "things"
-            }
+              name: "two",
+              misc: "things",
+            },
           ]
         ).suite_data.must_equal([
-          {
-            :name => "one",
-            :stuff => "junk"
-          },
-          {
-            :name => "two",
-            :misc => "things"
-          }
-        ])
+                                  {
+                                    name: "one",
+                                    stuff: "junk",
+                                  },
+                                  {
+                                    name: "two",
+                                    misc: "things",
+                                  },
+                                ])
       end
 
       it "returns an empty array if suites is not defined" do
@@ -87,18 +83,15 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     DATA_KEYS = {
-      :driver => :name,
-      :provisioner => :name,
-      :transport => :name,
-      :verifier => :name
-    }
+      driver: :name,
+      provisioner: :name,
+      transport: :name,
+      verifier: :name,
+    }.freeze
 
     DATA_KEYS.each_pair do |key, default_key|
-
       describe "##{key}" do
-
         describe "from single source" do
-
           it "returns empty hash if no common #{key} hash is provided" do
             DataMunger.new(
               {},
@@ -109,7 +102,7 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "drops common #{key} if hash is nil" do
             DataMunger.new(
               {
-                key => nil
+                key => nil,
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
@@ -118,10 +111,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns kitchen config #{key} name" do
             DataMunger.new(
               {},
-              {
-                :defaults => {
-                  key => "thenoseknows"
-                }
+              defaults: {
+                key => "thenoseknows",
               }
             ).public_send("#{key}_data_for", "suite", "platform").must_equal(
               default_key => "thenoseknows"
@@ -131,10 +122,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns kitchen config #{key} name from callable" do
             DataMunger.new(
               {},
-              {
-                :defaults => {
-                  key => ->(suite, platform) { "#{suite}++#{platform}" }
-                }
+              defaults: {
+                key => ->(suite, platform) { "#{suite}++#{platform}" },
               }
             ).public_send("#{key}_data_for", "suite", "platform").must_equal(
               default_key => "suite++platform"
@@ -144,7 +133,7 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns common #{key} name" do
             DataMunger.new(
               {
-                key => "starship"
+                key => "starship",
               },
               {}
             ).public_send("#{key}_data_for", "suite", "platform").must_equal(
@@ -157,8 +146,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
               {
                 key => {
                   default_key => "starship",
-                  :speed => 42
-                }
+                  :speed => 42,
+                },
               },
               {}
             ).public_send("#{key}_data_for", "suite", "platform").must_equal(
@@ -170,9 +159,9 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns empty hash if platform config doesn't have #{key} hash" do
             DataMunger.new(
               {
-                :platforms => [
-                  { :name => "plat" }
-                ]
+                platforms: [
+                  { name: "plat" },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
@@ -181,12 +170,12 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "drops platform #{key} if hash is nil" do
             DataMunger.new(
               {
-                :platforms => [
+                platforms: [
                   {
                     :name => "plat",
-                    key => nil
-                  }
-                ]
+                    key => nil,
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
@@ -195,12 +184,12 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns platform #{key} name" do
             DataMunger.new(
               {
-                :platforms => [
+                platforms: [
                   {
                     :name => "plat",
-                    key => "flip"
-                  }
-                ]
+                    key => "flip",
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal(
@@ -211,15 +200,15 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns platform config containing #{key} hash" do
             DataMunger.new(
               {
-                :platforms => [
+                platforms: [
                   {
                     :name => "plat",
                     key => {
                       default_key => "flip",
-                      :flop => "yep"
-                    }
-                  }
-                ]
+                      :flop => "yep",
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal(
@@ -231,9 +220,9 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns empty hash if suite config doesn't have #{key} hash" do
             DataMunger.new(
               {
-                :suites => [
-                  { :name => "sweet" }
-                ]
+                suites: [
+                  { name: "sweet" },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "platform").must_equal({})
@@ -242,12 +231,12 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "drops suite #{key} hash is nil" do
             DataMunger.new(
               {
-                :suites => [
+                suites: [
                   {
                     :name => "suite",
-                    key => nil
-                  }
-                ]
+                    key => nil,
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
@@ -256,12 +245,12 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns suite #{key} name" do
             DataMunger.new(
               {
-                :suites => [
+                suites: [
                   {
                     :name => "sweet",
-                    key => "waz"
-                  }
-                ]
+                    key => "waz",
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "platform").must_equal(
@@ -272,15 +261,15 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "returns suite config containing #{key} hash" do
             DataMunger.new(
               {
-                :suites => [
+                suites: [
                   {
                     :name => "sweet",
                     key => {
                       default_key => "waz",
-                      :up => "nope"
-                    }
-                  }
-                ]
+                      :up => "nope",
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "platform").must_equal(
@@ -291,15 +280,14 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         end
 
         describe "from multiple sources merging" do
-
           it "suite into platform into common" do
             DataMunger.new(
               {
                 key => {
                   default_key => "commony",
                   :color => "purple",
-                  :fruit => %w[apple pear],
-                  :deep => { :common => "junk" }
+                  :fruit => %w{apple pear},
+                  :deep => { common: "junk" },
                 },
                 :platforms => [
                   {
@@ -307,9 +295,9 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                     key => {
                       default_key => "platformy",
                       :fruit => ["banana"],
-                      :deep => { :platform => "stuff" }
-                    }
-                  }
+                      :deep => { platform: "stuff" },
+                    },
+                  },
                 ],
                 :suites => [
                   {
@@ -317,10 +305,10 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                     key => {
                       default_key => "suitey",
                       :vehicle => "car",
-                      :deep => { :suite => "things" }
-                    }
-                  }
-                ]
+                      :deep => { suite: "things" },
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
@@ -329,9 +317,9 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
               :fruit => ["banana"],
               :vehicle => "car",
               :deep => {
-                :common => "junk",
-                :platform => "stuff",
-                :suite => "things"
+                common: "junk",
+                platform: "stuff",
+                suite: "things",
               }
             )
           end
@@ -342,8 +330,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                 key => {
                   default_key => "commony",
                   :color => "purple",
-                  :fruit => %w[apple pear],
-                  :deep => { :common => "junk" }
+                  :fruit => %w{apple pear},
+                  :deep => { common: "junk" },
                 },
                 :platforms => [
                   {
@@ -351,10 +339,10 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                     key => {
                       default_key => "platformy",
                       :fruit => ["banana"],
-                      :deep => { :platform => "stuff" }
-                    }
-                  }
-                ]
+                      :deep => { platform: "stuff" },
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
@@ -362,8 +350,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
               :color => "purple",
               :fruit => ["banana"],
               :deep => {
-                :common => "junk",
-                :platform => "stuff"
+                common: "junk",
+                platform: "stuff",
               }
             )
           end
@@ -374,8 +362,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                 key => {
                   default_key => "commony",
                   :color => "purple",
-                  :fruit => %w[apple pear],
-                  :deep => { :common => "junk" }
+                  :fruit => %w{apple pear},
+                  :deep => { common: "junk" },
                 },
                 :suites => [
                   {
@@ -383,20 +371,20 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
                     key => {
                       default_key => "suitey",
                       :vehicle => "car",
-                      :deep => { :suite => "things" }
-                    }
-                  }
-                ]
+                      :deep => { suite: "things" },
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
               default_key => "suitey",
               :color => "purple",
-              :fruit => %w[apple pear],
+              :fruit => %w{apple pear},
               :vehicle => "car",
               :deep => {
-                :common => "junk",
-                :suite => "things"
+                common: "junk",
+                suite: "things",
               }
             )
           end
@@ -404,26 +392,26 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           it "suite into platform" do
             DataMunger.new(
               {
-                :platforms => [
+                platforms: [
                   {
                     :name => "plat",
                     key => {
                       default_key => "platformy",
                       :fruit => ["banana"],
-                      :deep => { :platform => "stuff" }
-                    }
-                  }
+                      :deep => { platform: "stuff" },
+                    },
+                  },
                 ],
-                :suites => [
+                suites: [
                   {
                     :name => "sweet",
                     key => {
                       default_key => "suitey",
                       :vehicle => "car",
-                      :deep => { :suite => "things" }
-                    }
-                  }
-                ]
+                      :deep => { suite: "things" },
+                    },
+                  },
+                ],
               },
               {}
             ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
@@ -431,8 +419,8 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
               :fruit => ["banana"],
               :vehicle => "car",
               :deep => {
-                :platform => "stuff",
-                :suite => "things"
+                platform: "stuff",
+                suite: "things",
               }
             )
           end
@@ -441,367 +429,363 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     describe "primary Chef data" do
-
       describe "in a suite" do
-
         it "moves attributes into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :suites => [
+              provisioner: "chefy",
+              suites: [
                 {
-                  :name => "sweet",
-                  :attributes => { :one => "two" }
-                }
-              ]
+                  name: "sweet",
+                  attributes: { one: "two" },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :attributes => { :one => "two" }
+            name: "chefy",
+            attributes: { one: "two" }
           )
         end
 
         it "moves run_list into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :suites => [
+              provisioner: "chefy",
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => %w[one two]
-                }
-              ]
+                  name: "sweet",
+                  run_list: %w{one two},
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "moves named_run_list into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :suites => [
+              provisioner: "chefy",
+              suites: [
                 {
-                  :name => "sweet",
-                  :named_run_list => "other_run_list"
-                }
-              ]
+                  name: "sweet",
+                  named_run_list: "other_run_list",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :named_run_list => "other_run_list"
+            name: "chefy",
+            named_run_list: "other_run_list"
           )
         end
         it "maintains run_list in provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :suites => [
+              provisioner: "chefy",
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => {
-                    :run_list => %w[one two]
-                  }
-                }
-              ]
+                  name: "sweet",
+                  provisioner: {
+                    run_list: %w{one two},
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "merge provisioner into attributes if provisioner exists" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :attributes => { :one => "two" },
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "sweet",
+                  attributes: { one: "two" },
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :attributes => { :one => "two" }
+            name: "chefy",
+            attributes: { one: "two" }
           )
         end
 
         it "merge provisioner into run_list if provisioner exists" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => %w[one two],
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "sweet",
+                  run_list: %w{one two},
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "merge provisioner into named_run_list if provisioner exists" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :named_run_list => "other_run_list",
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "sweet",
+                  named_run_list: "other_run_list",
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :named_run_list => "other_run_list"
+            name: "chefy",
+            named_run_list: "other_run_list"
           )
         end
         it "drops nil run_list" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => nil,
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "sweet",
+                  run_list: nil,
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy"
+            name: "chefy"
           )
         end
 
         it "drops nil attributes" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :attributes => nil,
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "sweet",
+                  attributes: nil,
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy"
+            name: "chefy"
           )
         end
       end
 
       describe "in a platform" do
-
         it "moves attributes into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :attributes => { :one => "two" }
-                }
-              ]
+                  name: "plat",
+                  attributes: { one: "two" },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :attributes => { :one => "two" }
+            name: "chefy",
+            attributes: { one: "two" }
           )
         end
 
         it "moves run_list into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :run_list => %w[one two]
-                }
-              ]
+                  name: "plat",
+                  run_list: %w{one two},
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "moves named_run_list into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :named_run_list => "other_run_list"
-                }
-              ]
+                  name: "plat",
+                  named_run_list: "other_run_list",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :named_run_list => "other_run_list"
+            name: "chefy",
+            named_run_list: "other_run_list"
           )
         end
         it "maintains run_list in provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => {
-                    :run_list => %w[one two]
-                  }
-                }
-              ]
+                  name: "plat",
+                  provisioner: {
+                    run_list: %w{one two},
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "merge provisioner into attributes if provisioner exists" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :attributes => { :one => "two" },
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "plat",
+                  attributes: { one: "two" },
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :attributes => { :one => "two" }
+            name: "chefy",
+            attributes: { one: "two" }
           )
         end
 
         it "merge provisioner into run_list if provisioner exists" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :run_list => %w[one two],
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "plat",
+                  run_list: %w{one two},
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two]
+            name: "chefy",
+            run_list: %w{one two}
           )
         end
 
         it "merge provisioner into named_run_list if provisioner exists" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :named_run_list => "other_run_list",
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "plat",
+                  named_run_list: "other_run_list",
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :named_run_list => "other_run_list"
+            name: "chefy",
+            named_run_list: "other_run_list"
           )
         end
         it "drops nil run_list" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :run_list => nil,
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "plat",
+                  run_list: nil,
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy"
+            name: "chefy"
           )
         end
 
         it "drops nil attributes" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :attributes => nil,
-                  :provisioner => "chefy"
-                }
-              ]
+                  name: "plat",
+                  attributes: nil,
+                  provisioner: "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy"
+            name: "chefy"
           )
         end
       end
 
       describe "in a suite and platform" do
-
         it "merges suite attributes into platform attributes" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :attributes => {
-                    :color => "blue",
-                    :deep => { :platform => "much" }
-                  }
-                }
+                  name: "plat",
+                  attributes: {
+                    color: "blue",
+                    deep: { platform: "much" },
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :attributes => {
-                    :color => "pink",
-                    :deep => { :suite => "wow" }
-                  }
-                }
-              ]
+                  name: "sweet",
+                  attributes: {
+                    color: "pink",
+                    deep: { suite: "wow" },
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :attributes => {
-              :color => "pink",
-              :deep => {
-                :suite => "wow",
-                :platform => "much"
-              }
+            name: "chefy",
+            attributes: {
+              color: "pink",
+              deep: {
+                suite: "wow",
+                platform: "much",
+              },
             }
           )
         end
@@ -809,130 +793,130 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "concats suite run_list to platform run_list" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :run_list => %w[one two]
-                }
+                  name: "plat",
+                  run_list: %w{one two},
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => %w[three four]
-                }
-              ]
+                  name: "sweet",
+                  run_list: %w{three four},
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two three four]
+            name: "chefy",
+            run_list: %w{one two three four}
           )
         end
 
         it "concats suite run_list in provisioner to platform run_list" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :run_list => %w[one two]
-                }
+                  name: "plat",
+                  run_list: %w{one two},
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => {
-                    :run_list => %w[three four]
-                  }
-                }
-              ]
+                  name: "sweet",
+                  provisioner: {
+                    run_list: %w{three four},
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two three four]
+            name: "chefy",
+            run_list: %w{one two three four}
           )
         end
 
         it "concats suite run_list to platform run_list in provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => {
-                    :run_list => %w[one two]
-                  }
-                }
+                  name: "plat",
+                  provisioner: {
+                    run_list: %w{one two},
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => %w[three four]
-                }
-              ]
+                  name: "sweet",
+                  run_list: %w{three four},
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two three four]
+            name: "chefy",
+            run_list: %w{one two three four}
           )
         end
 
         it "concats to nil run_lists into an empty Array" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => {
-                    :run_list => nil
-                  }
-                }
+                  name: "plat",
+                  provisioner: {
+                    run_list: nil,
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :run_list => nil
-                }
-              ]
+                  name: "sweet",
+                  run_list: nil,
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            :run_list => []
+            name: "chefy",
+            run_list: []
           )
         end
 
         it "does not corrupt run_list data for multiple suite/platform pairs" do
           munger = DataMunger.new(
             {
-              :provisioner => "chefy",
-              :platforms => [
+              provisioner: "chefy",
+              platforms: [
                 {
-                  :name => "p1"
+                  name: "p1",
                 },
                 {
-                  :name => "p2",
-                  :run_list => %w[one two]
-                }
+                  name: "p2",
+                  run_list: %w{one two},
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "s1",
-                  :run_list => %w[alpha beta]
+                  name: "s1",
+                  run_list: %w{alpha beta},
                 },
                 {
-                  :name => "s2",
-                  :provisioner => {
-                    :run_list => %w[three four]
-                  }
-                }
-              ]
+                  name: "s2",
+                  provisioner: {
+                    run_list: %w{three four},
+                  },
+                },
+              ],
             },
             {}
           )
@@ -944,35 +928,29 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
           munger.provisioner_data_for("s2", "p1")
 
           munger.provisioner_data_for("s2", "p2").must_equal(
-            :name => "chefy",
-            :run_list => %w[one two three four]
+            name: "chefy",
+            run_list: %w{one two three four}
           )
         end
       end
     end
 
     describe "kitchen config" do
-
       [:kitchen_root, :test_base_path].each do |key|
-
         describe "for #{key}" do
-
           describe "for #driver_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).driver_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -982,16 +960,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).driver_data_for("sweet", "plat").must_equal(
@@ -1003,20 +981,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).driver_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1026,40 +1002,37 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in driver data" do
               DataMunger.new(
                 {
-                  :driver => {
+                  driver: {
                     :name => "chefy",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy"
+                name: "chefy"
               )
             end
           end
 
           describe "for #provisioner_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :provisioner => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  provisioner: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).provisioner_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1069,16 +1042,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :provisioner => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  provisioner: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).provisioner_data_for("sweet", "plat").must_equal(
@@ -1090,20 +1063,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :provisioner => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  provisioner: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).provisioner_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1113,40 +1084,37 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in provisioner data" do
               DataMunger.new(
                 {
-                  :provisioner => {
+                  provisioner: {
                     :name => "chefy",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy"
+                name: "chefy"
               )
             end
           end
 
           describe "for #verifier_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).verifier_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1156,16 +1124,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).verifier_data_for("sweet", "plat").must_equal(
@@ -1177,20 +1145,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).verifier_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1200,40 +1166,37 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in verifier data" do
               DataMunger.new(
                 {
-                  :verifier => {
+                  verifier: {
                     :version => "chefy",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).verifier_data_for("sweet", "plat").must_equal(
-                :version => "chefy"
+                version: "chefy"
               )
             end
           end
 
           describe "for #transport_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).transport_data_for("sweet", "plat").must_equal(
                 :name => "pipes",
                 key => "datvalue"
@@ -1243,16 +1206,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).transport_data_for("sweet", "plat").must_equal(
@@ -1264,20 +1227,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).transport_data_for("sweet", "plat").must_equal(
                 :name => "pipes",
                 key => "datvalue"
@@ -1287,20 +1248,20 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in transport data" do
               DataMunger.new(
                 {
-                  :transport => {
+                  transport: {
                     :name => "pipes",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes"
+                name: "pipes"
               )
             end
           end
@@ -1308,25 +1269,20 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
       end
 
       [:log_level].each do |key|
-
         describe "for #{key}" do
-
           describe "for #driver_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).driver_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1336,16 +1292,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).driver_data_for("sweet", "plat").must_equal(
@@ -1357,20 +1313,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :driver => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  driver: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).driver_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1380,39 +1334,38 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in driver data" do
               DataMunger.new(
                 {
-                  :driver => {
+                  driver: {
                     :name => "chefy",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy"
+                name: "chefy"
               )
             end
           end
 
           describe "for #provisioner_data_for" do
-
             it "uses value in provisioner data" do
               DataMunger.new(
                 {
-                  :provisioner => {
+                  provisioner: {
                     :name => "chefy",
-                    key => "datvalue"
+                    key => "datvalue",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).provisioner_data_for("sweet", "plat").must_equal(
@@ -1424,40 +1377,37 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "imevil"
+                  kitchen: {
+                    key => "imevil",
                   },
-                  :provisioner => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  provisioner: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy"
+                name: "chefy"
               )
             end
           end
 
           describe "for #verifier_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).verifier_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1467,16 +1417,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).verifier_data_for("sweet", "plat").must_equal(
@@ -1488,20 +1438,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :verifier => "chefy",
-                  :platforms => [
-                    { :name => "plat" }
+                  verifier: "chefy",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).verifier_data_for("sweet", "plat").must_equal(
                 :name => "chefy",
                 key => "datvalue"
@@ -1511,40 +1459,37 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in verifier data" do
               DataMunger.new(
                 {
-                  :verifier => {
+                  verifier: {
                     :version => "chefy",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).verifier_data_for("sweet", "plat").must_equal(
-                :version => "chefy"
+                version: "chefy"
               )
             end
           end
 
           describe "for #transport_data_for" do
-
             it "is returned when provided" do
               DataMunger.new(
                 {
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "datvalue"
-                }
+                key => "datvalue"
               ).transport_data_for("sweet", "plat").must_equal(
                 :name => "pipes",
                 key => "datvalue"
@@ -1554,16 +1499,16 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "is returned when provided in user data" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).transport_data_for("sweet", "plat").must_equal(
@@ -1575,20 +1520,18 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "user data value beats provided value" do
               DataMunger.new(
                 {
-                  :kitchen => {
-                    key => "datvalue"
+                  kitchen: {
+                    key => "datvalue",
                   },
-                  :transport => "pipes",
-                  :platforms => [
-                    { :name => "plat" }
+                  transport: "pipes",
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
-                {
-                  key => "ilose"
-                }
+                key => "ilose"
               ).transport_data_for("sweet", "plat").must_equal(
                 :name => "pipes",
                 key => "datvalue"
@@ -1598,20 +1541,20 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
             it "rejects any value in transport data" do
               DataMunger.new(
                 {
-                  :transport => {
+                  transport: {
                     :name => "pipes",
-                    key => "imevil"
+                    key => "imevil",
                   },
-                  :platforms => [
-                    { :name => "plat" }
+                  platforms: [
+                    { name: "plat" },
+                  ],
+                  suites: [
+                    { name: "sweet" },
                   ],
-                  :suites => [
-                    { :name => "sweet" }
-                  ]
                 },
                 {}
               ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes"
+                name: "pipes"
               )
             end
           end
@@ -1620,198 +1563,195 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     describe "legacy driver_config and driver_plugin" do
-
       describe "from a single source" do
-
         it "returns common driver name" do
           DataMunger.new(
             {
-              :driver_plugin => "starship"
+              driver_plugin: "starship",
             },
             {}
           ).driver_data_for("suite", "platform").must_equal(
-            :name => "starship"
+            name: "starship"
           )
         end
 
         it "merges driver into driver_plugin if driver exists" do
           DataMunger.new(
             {
-              :driver_plugin => "starship",
-              :driver => "zappa"
+              driver_plugin: "starship",
+              driver: "zappa",
             },
             {}
           ).driver_data_for("suite", "platform").must_equal(
-            :name => "zappa"
+            name: "zappa"
           )
         end
 
         it "returns common driver config" do
           DataMunger.new(
             {
-              :driver_plugin => "starship",
-              :driver_config => {
-                :speed => 42
-              }
+              driver_plugin: "starship",
+              driver_config: {
+                speed: 42,
+              },
             },
             {}
           ).driver_data_for("suite", "platform").must_equal(
-            :name => "starship",
-            :speed => 42
+            name: "starship",
+            speed: 42
           )
         end
 
         it "merges driver into driver_config if driver with name exists" do
           DataMunger.new(
             {
-              :driver_config => {
-                :eh => "yep"
+              driver_config: {
+                eh: "yep",
               },
-              :driver => "zappa"
+              driver: "zappa",
             },
             {}
           ).driver_data_for("suite", "platform").must_equal(
-            :name => "zappa",
-            :eh => "yep"
+            name: "zappa",
+            eh: "yep"
           )
         end
 
         it "merges driver into driver_config if driver exists" do
           DataMunger.new(
             {
-              :driver_plugin => "imold",
-              :driver_config => {
-                :eh => "yep",
-                :color => "pink"
+              driver_plugin: "imold",
+              driver_config: {
+                eh: "yep",
+                color: "pink",
+              },
+              driver: {
+                name: "zappa",
+                color: "black",
               },
-              :driver => {
-                :name => "zappa",
-                :color => "black"
-              }
             },
             {}
           ).driver_data_for("suite", "platform").must_equal(
-            :name => "zappa",
-            :eh => "yep",
-            :color => "black"
+            name: "zappa",
+            eh: "yep",
+            color: "black"
           )
         end
 
         it "returns platform driver name" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :driver_plugin => "flip"
-                }
-              ]
+                  name: "plat",
+                  driver_plugin: "flip",
+                },
+              ],
             },
             {}
           ).driver_data_for("suite", "plat").must_equal(
-            :name => "flip"
+            name: "flip"
           )
         end
 
         it "returns platform config containing driver hash" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :driver_plugin => "flip",
-                  :driver_config => {
-                    :flop => "yep"
-                  }
-                }
-              ]
+                  name: "plat",
+                  driver_plugin: "flip",
+                  driver_config: {
+                    flop: "yep",
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("suite", "plat").must_equal(
-            :name => "flip",
-            :flop => "yep"
+            name: "flip",
+            flop: "yep"
           )
         end
 
         it "returns suite driver name" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :driver_plugin => "waz"
-                }
-              ]
+                  name: "sweet",
+                  driver_plugin: "waz",
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "platform").must_equal(
-            :name => "waz"
+            name: "waz"
           )
         end
 
         it "returns suite config containing driver hash" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :driver_plugin => "waz",
-                  :driver_config => {
-                    :up => "nope"
-                  }
-                }
-              ]
+                  name: "sweet",
+                  driver_plugin: "waz",
+                  driver_config: {
+                    up: "nope",
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "platform").must_equal(
-            :name => "waz",
-            :up => "nope"
+            name: "waz",
+            up: "nope"
           )
         end
       end
 
       describe "from multiple sources" do
-
         it "suite into platform into common" do
           DataMunger.new(
             {
-              :driver_plugin => "commony",
-              :driver_config => {
-                :color => "purple",
-                :fruit => %w[apple pear],
-                :deep => { :common => "junk" }
+              driver_plugin: "commony",
+              driver_config: {
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :driver_plugin => "platformy",
-                  :driver_config => {
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
+                  name: "plat",
+                  driver_plugin: "platformy",
+                  driver_config: {
+                    fruit: ["banana"],
+                    deep: { platform: "stuff" },
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :driver_plugin => "suitey",
-                  :driver_config => {
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  name: "sweet",
+                  driver_plugin: "suitey",
+                  driver_config: {
+                    vehicle: "car",
+                    deep: { suite: "things" },
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "plat").must_equal(
-            :name => "suitey",
-            :color => "purple",
-            :fruit => ["banana"],
-            :vehicle => "car",
-            :deep => {
-              :common => "junk",
-              :platform => "stuff",
-              :suite => "things"
+            name: "suitey",
+            color: "purple",
+            fruit: ["banana"],
+            vehicle: "car",
+            deep: {
+              common: "junk",
+              platform: "stuff",
+              suite: "things",
             }
           )
         end
@@ -1819,31 +1759,31 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "platform into common" do
           DataMunger.new(
             {
-              :driver_plugin => "commony",
-              :driver_config => {
-                :color => "purple",
-                :fruit => %w[apple pear],
-                :deep => { :common => "junk" }
+              driver_plugin: "commony",
+              driver_config: {
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :driver_plugin => "platformy",
-                  :driver_config => {
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
-              ]
+                  name: "plat",
+                  driver_plugin: "platformy",
+                  driver_config: {
+                    fruit: ["banana"],
+                    deep: { platform: "stuff" },
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "plat").must_equal(
-            :name => "platformy",
-            :color => "purple",
-            :fruit => ["banana"],
-            :deep => {
-              :common => "junk",
-              :platform => "stuff"
+            name: "platformy",
+            color: "purple",
+            fruit: ["banana"],
+            deep: {
+              common: "junk",
+              platform: "stuff",
             }
           )
         end
@@ -1851,32 +1791,32 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "suite into common" do
           DataMunger.new(
             {
-              :driver_plugin => "commony",
-              :driver_config => {
-                :color => "purple",
-                :fruit => %w[apple pear],
-                :deep => { :common => "junk" }
+              driver_plugin: "commony",
+              driver_config: {
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :driver_plugin => "suitey",
-                  :driver_config => {
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  name: "sweet",
+                  driver_plugin: "suitey",
+                  driver_config: {
+                    vehicle: "car",
+                    deep: { suite: "things" },
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "plat").must_equal(
-            :name => "suitey",
-            :color => "purple",
-            :fruit => %w[apple pear],
-            :vehicle => "car",
-            :deep => {
-              :common => "junk",
-              :suite => "things"
+            name: "suitey",
+            color: "purple",
+            fruit: %w{apple pear},
+            vehicle: "car",
+            deep: {
+              common: "junk",
+              suite: "things",
             }
           )
         end
@@ -1884,35 +1824,35 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "suite into platform" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :driver_plugin => "platformy",
-                  :driver_config => {
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
+                  name: "plat",
+                  driver_plugin: "platformy",
+                  driver_config: {
+                    fruit: ["banana"],
+                    deep: { platform: "stuff" },
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :driver_plugin => "suitey",
-                  :driver_config => {
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  name: "sweet",
+                  driver_plugin: "suitey",
+                  driver_config: {
+                    vehicle: "car",
+                    deep: { suite: "things" },
+                  },
+                },
+              ],
             },
             {}
           ).driver_data_for("sweet", "plat").must_equal(
-            :name => "suitey",
-            :fruit => ["banana"],
-            :vehicle => "car",
-            :deep => {
-              :platform => "stuff",
-              :suite => "things"
+            name: "suitey",
+            fruit: ["banana"],
+            vehicle: "car",
+            deep: {
+              platform: "stuff",
+              suite: "things",
             }
           )
         end
@@ -1920,24 +1860,22 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     describe "legacy chef paths from suite" do
-
       LEGACY_CHEF_PATHS = [
         :data_path, :data_bags_path, :environments_path,
         :nodes_path, :roles_path, :encrypted_data_bag_secret_key_path
-      ]
+      ].freeze
 
       LEGACY_CHEF_PATHS.each do |key|
-
         it "moves #{key} into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :suites => [
+              provisioner: "chefy",
+              suites: [
                 {
                   :name => "sweet",
-                  key => "mypath"
-                }
-              ]
+                  key => "mypath",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
@@ -1949,13 +1887,13 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "merges provisioner into data_path if provisioner exists" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
                   :name => "sweet",
                   key => "mypath",
-                  :provisioner => "chefy"
-                }
-              ]
+                  :provisioner => "chefy",
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "plat").must_equal(
@@ -1967,688 +1905,681 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
     end
 
     describe "legacy require_chef_omnibus from driver" do
-
       describe "from a single source" do
-
         it "common driver value moves into provisioner" do
           DataMunger.new(
             {
-              :provisioner => "chefy",
-              :driver => {
-                :name => "starship",
-                :require_chef_omnibus => "it's probably fine"
-              }
+              provisioner: "chefy",
+              driver: {
+                name: "starship",
+                require_chef_omnibus: "it's probably fine",
+              },
             },
             {}
           ).provisioner_data_for("suite", "platform").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         end
 
         it "common driver value loses to existing provisioner value" do
           DataMunger.new(
             {
-              :provisioner => {
-                :name => "chefy",
-                :require_chef_omnibus => "it's probably fine"
+              provisioner: {
+                name: "chefy",
+                require_chef_omnibus: "it's probably fine",
+              },
+              driver: {
+                name: "starship",
+                require_chef_omnibus: "dragons",
               },
-              :driver => {
-                :name => "starship",
-                :require_chef_omnibus => "dragons"
-              }
             },
             {}
           ).provisioner_data_for("suite", "platform").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         end
 
         it "suite driver value moves into provisioner" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :require_chef_omnibus => "it's probably fine"
-                  }
-                }
-              ]
+                  name: "sweet",
+                  provisioner: "chefy",
+                  driver: {
+                    name: "starship",
+                    require_chef_omnibus: "it's probably fine",
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "platform").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         end
 
         it "suite driver value loses to existing provisioner value" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => {
-                    :name => "chefy",
-                    :require_chef_omnibus => "it's probably fine"
+                  name: "sweet",
+                  provisioner: {
+                    name: "chefy",
+                    require_chef_omnibus: "it's probably fine",
+                  },
+                  driver: {
+                    name: "starship",
+                    require_chef_omnibus: "dragons",
                   },
-                  :driver => {
-                    :name => "starship",
-                    :require_chef_omnibus => "dragons"
-                  }
-                }
-              ]
+                },
+              ],
             },
             {}
           ).provisioner_data_for("sweet", "platform").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         end
 
         it "platform driver value moves into provisioner" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :require_chef_omnibus => "it's probably fine"
-                  }
-                }
-              ]
+                  name: "plat",
+                  provisioner: "chefy",
+                  driver: {
+                    name: "starship",
+                    require_chef_omnibus: "it's probably fine",
+                  },
+                },
+              ],
             },
             {}
           ).provisioner_data_for("suite", "plat").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         end
 
         it "platform driver value loses to existing provisioner value" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => {
-                    :name => "chefy",
-                    :require_chef_omnibus => "it's probably fine"
+                  name: "plat",
+                  provisioner: {
+                    name: "chefy",
+                    require_chef_omnibus: "it's probably fine",
+                  },
+                  driver: {
+                    name: "starship",
+                    require_chef_omnibus: "dragons",
                   },
-                  :driver => {
-                    :name => "starship",
-                    :require_chef_omnibus => "dragons"
-                  }
-                }
-              ]
+                },
+              ],
             },
             {}
           ).provisioner_data_for("suite", "plat").must_equal(
-            :name => "chefy",
-            :require_chef_omnibus => "it's probably fine"
+            name: "chefy",
+            require_chef_omnibus: "it's probably fine"
           )
         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"
-              }
+              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"
+            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: "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"
+            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: "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"
+            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"
+              provisioner: {
+                name: "chefy",
+                http_proxy: "it's probably fine",
+                https_proxy: "la quinta",
+              },
+              driver: {
+                name: "starship",
+                http_proxy: "dragons",
+                https_proxy: "cats",
               },
-              :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"
+            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"
+              verifier: {
+                name: "bussy",
+                http_proxy: "it's probably fine",
+                https_proxy: "la quinta",
+              },
+              driver: {
+                name: "starship",
+                http_proxy: "dragons",
+                https_proxy: "cats",
               },
-              :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"
+            name: "bussy",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "suite driver value remains in driver" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            name: "starship",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "suite driver value copies into provisioner" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            name: "chefy",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "suite driver value copies into verifier" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :verifier => "bussy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            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 => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :provisioner => {
-                    :name => "chefy",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
+                  name: "sweet",
+                  provisioner: {
+                    name: "chefy",
+                    http_proxy: "it's probably fine",
+                    https_proxy: "la quinta",
+                  },
+                  driver: {
+                    name: "starship",
+                    http_proxy: "dragons",
+                    https_proxy: "cats",
                   },
-                  :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"
+            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 => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :verifier => {
-                    :name => "bussy",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
+                  name: "sweet",
+                  verifier: {
+                    name: "bussy",
+                    http_proxy: "it's probably fine",
+                    https_proxy: "la quinta",
                   },
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "dragons",
-                    :https_proxy => "cats"
-                  }
-                }
-              ]
+                  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"
+            name: "bussy",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "platform driver value remains in driver" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            name: "starship",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "platform driver value copies into provisioner" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => "chefy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            name: "chefy",
+            http_proxy: "it's probably fine",
+            https_proxy: "la quinta"
           )
         end
 
         it "platform driver value copies into verifier" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :verifier => "bussy",
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
-                  }
-                }
-              ]
+                  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"
+            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 => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :provisioner => {
-                    :name => "chefy",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
+                  name: "plat",
+                  provisioner: {
+                    name: "chefy",
+                    http_proxy: "it's probably fine",
+                    https_proxy: "la quinta",
                   },
-                  :driver => {
-                    :name => "starship",
-                    :http_proxy => "dragons",
-                    :https_proxy => "cats"
-                  }
-                }
-              ]
+                  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"
+            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 => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :verifier => {
-                    :name => "bussy",
-                    :http_proxy => "it's probably fine",
-                    :https_proxy => "la quinta"
+                  name: "plat",
+                  verifier: {
+                    name: "bussy",
+                    http_proxy: "it's probably fine",
+                    https_proxy: "la quinta",
+                  },
+                  driver: {
+                    name: "starship",
+                    http_proxy: "dragons",
+                    https_proxy: "cats",
                   },
-                  :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"
+            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"
+              busser: "starship",
             },
             {}
           ).verifier_data_for("suite", "platform").must_equal(
-            :name => "busser",
-            :version => "starship"
+            name: "busser",
+            version: "starship"
           )
         end
 
         it "merges old common busser name to version with exising verifier" do
           DataMunger.new(
             {
-              :busser => "starship",
-              :verifier => {
-                :a => "b"
-              }
+              busser: "starship",
+              verifier: {
+                a: "b",
+              },
             },
             {}
           ).verifier_data_for("suite", "platform").must_equal(
-            :name => "busser",
-            :version => "starship",
-            :a => "b"
+            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"
+              busser: "starship",
+              verifier: "stellar",
             },
             {}
           ).verifier_data_for("suite", "platform").must_equal(
-            :name => "stellar",
-            :version => "starship"
+            name: "stellar",
+            version: "starship"
           )
         end
 
         it "merges old busser data into verifier with name" do
           DataMunger.new(
             {
-              :busser => {
-                :a => "b"
+              busser: {
+                a: "b",
               },
-              :verifier => "stellar"
+              verifier: "stellar",
             },
             {}
           ).verifier_data_for("suite", "platform").must_equal(
-            :name => "stellar",
-            :a => "b"
+            name: "stellar",
+            a: "b"
           )
         end
 
         it "merges old busser data into verifier data" do
           DataMunger.new(
             {
-              :busser => {
-                :a => "b",
-                :both => "legacy"
+              busser: {
+                a: "b",
+                both: "legacy",
+              },
+              verifier: {
+                name: "stellar",
+                c: "d",
+                both: "modern",
               },
-              :verifier => {
-                :name => "stellar",
-                :c => "d",
-                :both => "modern"
-              }
             },
             {}
           ).verifier_data_for("suite", "platform").must_equal(
-            :name => "stellar",
-            :a => "b",
-            :c => "d",
-            :both => "modern"
+            name: "stellar",
+            a: "b",
+            c: "d",
+            both: "modern"
           )
         end
 
         it "returns platform verifier name" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :busser => "flip"
-                }
-              ]
+                  name: "plat",
+                  busser: "flip",
+                },
+              ],
             },
             {}
           ).verifier_data_for("suite", "plat").must_equal(
-            :name => "busser",
-            :version => "flip"
+            name: "busser",
+            version: "flip"
           )
         end
 
         it "return platform config containing verifier hash" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :busser => "flip",
-                  :verifier => {
-                    :flop => "yep"
-                  }
-                }
-              ]
+                  name: "plat",
+                  busser: "flip",
+                  verifier: {
+                    flop: "yep",
+                  },
+                },
+              ],
             },
             {}
           ).verifier_data_for("suite", "plat").must_equal(
-            :name => "busser",
-            :version => "flip",
-            :flop => "yep"
+            name: "busser",
+            version: "flip",
+            flop: "yep"
           )
         end
 
         it "returns suite driver name" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :busser => "waz"
-                }
-              ]
+                  name: "sweet",
+                  busser: "waz",
+                },
+              ],
             },
             {}
           ).verifier_data_for("sweet", "platform").must_equal(
-            :name => "busser",
-            :version => "waz"
+            name: "busser",
+            version: "waz"
           )
         end
 
         it "returns suite config containing verifier hash" do
           DataMunger.new(
             {
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :busser => "waz",
-                  :verifier => {
-                    :up => "nope"
-                  }
-                }
-              ]
+                  name: "sweet",
+                  busser: "waz",
+                  verifier: {
+                    up: "nope",
+                  },
+                },
+              ],
             },
             {}
           ).verifier_data_for("sweet", "platform").must_equal(
-            :name => "busser",
-            :version => "waz",
-            :up => "nope"
+            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" }
+              busser: {
+                version: "commony",
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :busser => {
-                    :version => "platformy",
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
+                  name: "plat",
+                  busser: {
+                    version: "platformy",
+                    fruit: ["banana"],
+                    deep: { platform: "stuff" },
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :busser => {
-                    :version => "suitey",
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  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"
+            name: "busser",
+            version: "suitey",
+            color: "purple",
+            fruit: ["banana"],
+            vehicle: "car",
+            deep: {
+              common: "junk",
+              platform: "stuff",
+              suite: "things",
             }
           )
         end
@@ -2656,32 +2587,32 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "platform into common" do
           DataMunger.new(
             {
-              :busser => {
-                :version => "commony",
-                :color => "purple",
-                :fruit => %w[apple pear],
-                :deep => { :common => "junk" }
+              busser: {
+                version: "commony",
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :busser => {
-                    :version => "platformy",
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
-              ]
+                  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"
+            name: "busser",
+            version: "platformy",
+            color: "purple",
+            fruit: ["banana"],
+            deep: {
+              common: "junk",
+              platform: "stuff",
             }
           )
         end
@@ -2689,33 +2620,33 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "suite into common" do
           DataMunger.new(
             {
-              :busser => {
-                :version => "commony",
-                :color => "purple",
-                :fruit => %w[apple pear],
-                :deep => { :common => "junk" }
+              busser: {
+                version: "commony",
+                color: "purple",
+                fruit: %w{apple pear},
+                deep: { common: "junk" },
               },
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :busser => {
-                    :version => "suitey",
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  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"
+            name: "busser",
+            version: "suitey",
+            color: "purple",
+            fruit: %w{apple pear},
+            vehicle: "car",
+            deep: {
+              common: "junk",
+              suite: "things",
             }
           )
         end
@@ -2723,36 +2654,36 @@ module Kitchen # rubocop:disable Metrics/ModuleLength
         it "suite into platform" do
           DataMunger.new(
             {
-              :platforms => [
+              platforms: [
                 {
-                  :name => "plat",
-                  :busser => {
-                    :version => "platformy",
-                    :fruit => ["banana"],
-                    :deep => { :platform => "stuff" }
-                  }
-                }
+                  name: "plat",
+                  busser: {
+                    version: "platformy",
+                    fruit: ["banana"],
+                    deep: { platform: "stuff" },
+                  },
+                },
               ],
-              :suites => [
+              suites: [
                 {
-                  :name => "sweet",
-                  :busser => {
-                    :version => "suitey",
-                    :vehicle => "car",
-                    :deep => { :suite => "things" }
-                  }
-                }
-              ]
+                  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"
+            name: "busser",
+            version: "suitey",
+            fruit: ["banana"],
+            vehicle: "car",
+            deep: {
+              platform: "stuff",
+              suite: "things",
             }
           )
         end