test-kitchen 1.23.3 → 1.23.4

data/spec/kitchen/data_munger_spec.rb

@@ -1,2800 +0,0 @@
-# -*- encoding: utf-8 -*-
-#
-# Author:: Fletcher Nichol (<fnichol@nichol.ca>)
-#
-# Copyright (C) 2013, Fletcher Nichol
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#    http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-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: [
-            {
-              name: "one",
-              stuff: "junk",
-            },
-            {
-              name: "two",
-              misc: "things",
-            },
-          ]
-        ).platform_data.must_equal([
-                                     {
-                                       name: "one",
-                                       stuff: "junk",
-                                     },
-                                     {
-                                       name: "two",
-                                       misc: "things",
-                                     },
-                                   ])
-      end
-
-      it "returns an empty array if platforms is not defined" do
-        DataMunger.new({}).platform_data.must_equal([])
-      end
-    end
-
-    describe "#suite_data" do
-      it "returns an array of suite data" do
-        DataMunger.new(
-          suites: [
-            {
-              name: "one",
-              stuff: "junk",
-            },
-            {
-              name: "two",
-              misc: "things",
-            },
-          ]
-        ).suite_data.must_equal([
-                                  {
-                                    name: "one",
-                                    stuff: "junk",
-                                  },
-                                  {
-                                    name: "two",
-                                    misc: "things",
-                                  },
-                                ])
-      end
-
-      it "returns an empty array if suites is not defined" do
-        DataMunger.new({}).suite_data.must_equal([])
-      end
-    end
-
-    DATA_KEYS = {
-      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(
-              {},
-              {}
-            ).public_send("#{key}_data_for", "suite", "platform").must_equal({})
-          end
-
-          it "drops common #{key} if hash is nil" do
-            DataMunger.new(
-              {
-                key => nil,
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
-          end
-
-          it "returns kitchen config #{key} name" do
-            DataMunger.new(
-              {},
-              defaults: {
-                key => "thenoseknows",
-              }
-            ).public_send("#{key}_data_for", "suite", "platform").must_equal(
-              default_key => "thenoseknows"
-            )
-          end
-
-          it "returns kitchen config #{key} name from callable" do
-            DataMunger.new(
-              {},
-              defaults: {
-                key => ->(suite, platform) { "#{suite}++#{platform}" },
-              }
-            ).public_send("#{key}_data_for", "suite", "platform").must_equal(
-              default_key => "suite++platform"
-            )
-          end
-
-          it "returns common #{key} name" do
-            DataMunger.new(
-              {
-                key => "starship",
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "platform").must_equal(
-              default_key => "starship"
-            )
-          end
-
-          it "returns common #{key} config" do
-            DataMunger.new(
-              {
-                key => {
-                  default_key => "starship",
-                  :speed => 42,
-                },
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "platform").must_equal(
-              default_key => "starship",
-              :speed => 42
-            )
-          end
-
-          it "returns empty hash if platform config doesn't have #{key} hash" do
-            DataMunger.new(
-              {
-                platforms: [
-                  { name: "plat" },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
-          end
-
-          it "drops platform #{key} if hash is nil" do
-            DataMunger.new(
-              {
-                platforms: [
-                  {
-                    :name => "plat",
-                    key => nil,
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
-          end
-
-          it "returns platform #{key} name" do
-            DataMunger.new(
-              {
-                platforms: [
-                  {
-                    :name => "plat",
-                    key => "flip",
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal(
-              default_key => "flip"
-            )
-          end
-
-          it "returns platform config containing #{key} hash" do
-            DataMunger.new(
-              {
-                platforms: [
-                  {
-                    :name => "plat",
-                    key => {
-                      default_key => "flip",
-                      :flop => "yep",
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal(
-              default_key => "flip",
-              :flop => "yep"
-            )
-          end
-
-          it "returns empty hash if suite config doesn't have #{key} hash" do
-            DataMunger.new(
-              {
-                suites: [
-                  { name: "sweet" },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "platform").must_equal({})
-          end
-
-          it "drops suite #{key} hash is nil" do
-            DataMunger.new(
-              {
-                suites: [
-                  {
-                    :name => "suite",
-                    key => nil,
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "suite", "plat").must_equal({})
-          end
-
-          it "returns suite #{key} name" do
-            DataMunger.new(
-              {
-                suites: [
-                  {
-                    :name => "sweet",
-                    key => "waz",
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "platform").must_equal(
-              default_key => "waz"
-            )
-          end
-
-          it "returns suite config containing #{key} hash" do
-            DataMunger.new(
-              {
-                suites: [
-                  {
-                    :name => "sweet",
-                    key => {
-                      default_key => "waz",
-                      :up => "nope",
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "platform").must_equal(
-              default_key => "waz",
-              :up => "nope"
-            )
-          end
-        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" },
-                },
-                :platforms => [
-                  {
-                    :name => "plat",
-                    key => {
-                      default_key => "platformy",
-                      :fruit => ["banana"],
-                      :deep => { platform: "stuff" },
-                    },
-                  },
-                ],
-                :suites => [
-                  {
-                    :name => "sweet",
-                    key => {
-                      default_key => "suitey",
-                      :vehicle => "car",
-                      :deep => { suite: "things" },
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
-              default_key => "suitey",
-              :color => "purple",
-              :fruit => ["banana"],
-              :vehicle => "car",
-              :deep => {
-                common: "junk",
-                platform: "stuff",
-                suite: "things",
-              }
-            )
-          end
-
-          it "platform into common" do
-            DataMunger.new(
-              {
-                key => {
-                  default_key => "commony",
-                  :color => "purple",
-                  :fruit => %w{apple pear},
-                  :deep => { common: "junk" },
-                },
-                :platforms => [
-                  {
-                    :name => "plat",
-                    key => {
-                      default_key => "platformy",
-                      :fruit => ["banana"],
-                      :deep => { platform: "stuff" },
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
-              default_key => "platformy",
-              :color => "purple",
-              :fruit => ["banana"],
-              :deep => {
-                common: "junk",
-                platform: "stuff",
-              }
-            )
-          end
-
-          it "suite into common" do
-            DataMunger.new(
-              {
-                key => {
-                  default_key => "commony",
-                  :color => "purple",
-                  :fruit => %w{apple pear},
-                  :deep => { common: "junk" },
-                },
-                :suites => [
-                  {
-                    :name => "sweet",
-                    key => {
-                      default_key => "suitey",
-                      :vehicle => "car",
-                      :deep => { suite: "things" },
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
-              default_key => "suitey",
-              :color => "purple",
-              :fruit => %w{apple pear},
-              :vehicle => "car",
-              :deep => {
-                common: "junk",
-                suite: "things",
-              }
-            )
-          end
-
-          it "suite into platform" do
-            DataMunger.new(
-              {
-                platforms: [
-                  {
-                    :name => "plat",
-                    key => {
-                      default_key => "platformy",
-                      :fruit => ["banana"],
-                      :deep => { platform: "stuff" },
-                    },
-                  },
-                ],
-                suites: [
-                  {
-                    :name => "sweet",
-                    key => {
-                      default_key => "suitey",
-                      :vehicle => "car",
-                      :deep => { suite: "things" },
-                    },
-                  },
-                ],
-              },
-              {}
-            ).public_send("#{key}_data_for", "sweet", "plat").must_equal(
-              default_key => "suitey",
-              :fruit => ["banana"],
-              :vehicle => "car",
-              :deep => {
-                platform: "stuff",
-                suite: "things",
-              }
-            )
-          end
-        end
-      end
-    end
-
-    describe "primary Chef data" do
-      describe "in a suite" do
-        it "moves attributes into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              suites: [
-                {
-                  name: "sweet",
-                  attributes: { one: "two" },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            attributes: { one: "two" }
-          )
-        end
-
-        it "moves run_list into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: %w{one two},
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "moves named_run_list into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              suites: [
-                {
-                  name: "sweet",
-                  named_run_list: "other_run_list",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            named_run_list: "other_run_list"
-          )
-        end
-        it "maintains run_list in provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: {
-                    run_list: %w{one two},
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "merge provisioner into attributes if provisioner exists" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  attributes: { one: "two" },
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            attributes: { one: "two" }
-          )
-        end
-
-        it "merge provisioner into run_list if provisioner exists" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: %w{one two},
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "merge provisioner into named_run_list if provisioner exists" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  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"
-          )
-        end
-        it "drops nil run_list" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: nil,
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy"
-          )
-        end
-
-        it "drops nil attributes" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  attributes: nil,
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy"
-          )
-        end
-      end
-
-      describe "in a platform" do
-        it "moves attributes into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  attributes: { one: "two" },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            attributes: { one: "two" }
-          )
-        end
-
-        it "moves run_list into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  run_list: %w{one two},
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "moves named_run_list into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  named_run_list: "other_run_list",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            named_run_list: "other_run_list"
-          )
-        end
-        it "maintains run_list in provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  provisioner: {
-                    run_list: %w{one two},
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "merge provisioner into attributes if provisioner exists" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  attributes: { one: "two" },
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            attributes: { one: "two" }
-          )
-        end
-
-        it "merge provisioner into run_list if provisioner exists" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  run_list: %w{one two},
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: %w{one two}
-          )
-        end
-
-        it "merge provisioner into named_run_list if provisioner exists" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  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"
-          )
-        end
-        it "drops nil run_list" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  run_list: nil,
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy"
-          )
-        end
-
-        it "drops nil attributes" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  attributes: nil,
-                  provisioner: "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy"
-          )
-        end
-      end
-
-      describe "in a suite and platform" do
-        it "merges suite attributes into platform attributes" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  attributes: {
-                    color: "blue",
-                    deep: { platform: "much" },
-                  },
-                },
-              ],
-              suites: [
-                {
-                  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",
-              },
-            }
-          )
-        end
-
-        it "concats suite run_list to platform run_list" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "plat",
-                  run_list: %w{one two},
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: %w{three four},
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            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: [
-                {
-                  name: "plat",
-                  run_list: %w{one two},
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: {
-                    run_list: %w{three four},
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            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: [
-                {
-                  name: "plat",
-                  provisioner: {
-                    run_list: %w{one two},
-                  },
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: %w{three four},
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            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: [
-                {
-                  name: "plat",
-                  provisioner: {
-                    run_list: nil,
-                  },
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  run_list: nil,
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            name: "chefy",
-            run_list: []
-          )
-        end
-
-        it "does not corrupt run_list data for multiple suite/platform pairs" do
-          munger = DataMunger.new(
-            {
-              provisioner: "chefy",
-              platforms: [
-                {
-                  name: "p1",
-                },
-                {
-                  name: "p2",
-                  run_list: %w{one two},
-                },
-              ],
-              suites: [
-                {
-                  name: "s1",
-                  run_list: %w{alpha beta},
-                },
-                {
-                  name: "s2",
-                  provisioner: {
-                    run_list: %w{three four},
-                  },
-                },
-              ],
-            },
-            {}
-          )
-
-          # call munger for other data to cause any necessary internal
-          # data mutation
-          munger.provisioner_data_for("s1", "p1")
-          munger.provisioner_data_for("s1", "p2")
-          munger.provisioner_data_for("s2", "p1")
-
-          munger.provisioner_data_for("s2", "p2").must_equal(
-            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" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  driver: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  driver: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in driver data" do
-              DataMunger.new(
-                {
-                  driver: {
-                    :name => "chefy",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).driver_data_for("sweet", "plat").must_equal(
-                name: "chefy"
-              )
-            end
-          end
-
-          describe "for #provisioner_data_for" do
-            it "is returned when provided" do
-              DataMunger.new(
-                {
-                  provisioner: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  provisioner: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  provisioner: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in provisioner data" do
-              DataMunger.new(
-                {
-                  provisioner: {
-                    :name => "chefy",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                name: "chefy"
-              )
-            end
-          end
-
-          describe "for #verifier_data_for" do
-            it "is returned when provided" do
-              DataMunger.new(
-                {
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in verifier data" do
-              DataMunger.new(
-                {
-                  verifier: {
-                    :version => "chefy",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).verifier_data_for("sweet", "plat").must_equal(
-                version: "chefy"
-              )
-            end
-          end
-
-          describe "for #transport_data_for" do
-            it "is returned when provided" do
-              DataMunger.new(
-                {
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in transport data" do
-              DataMunger.new(
-                {
-                  transport: {
-                    :name => "pipes",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).transport_data_for("sweet", "plat").must_equal(
-                name: "pipes"
-              )
-            end
-          end
-        end
-      end
-
-      [: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" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  driver: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  driver: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).driver_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in driver data" do
-              DataMunger.new(
-                {
-                  driver: {
-                    :name => "chefy",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).driver_data_for("sweet", "plat").must_equal(
-                name: "chefy"
-              )
-            end
-          end
-
-          describe "for #provisioner_data_for" do
-            it "uses value in provisioner data" do
-              DataMunger.new(
-                {
-                  provisioner: {
-                    :name => "chefy",
-                    key => "datvalue",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "imevil",
-                  },
-                  provisioner: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).provisioner_data_for("sweet", "plat").must_equal(
-                name: "chefy"
-              )
-            end
-          end
-
-          describe "for #verifier_data_for" do
-            it "is returned when provided" do
-              DataMunger.new(
-                {
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  verifier: "chefy",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).verifier_data_for("sweet", "plat").must_equal(
-                :name => "chefy",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in verifier data" do
-              DataMunger.new(
-                {
-                  verifier: {
-                    :version => "chefy",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).verifier_data_for("sweet", "plat").must_equal(
-                version: "chefy"
-              )
-            end
-          end
-
-          describe "for #transport_data_for" do
-            it "is returned when provided" do
-              DataMunger.new(
-                {
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "datvalue"
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "is returned when provided in user data" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "user data value beats provided value" do
-              DataMunger.new(
-                {
-                  kitchen: {
-                    key => "datvalue",
-                  },
-                  transport: "pipes",
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                key => "ilose"
-              ).transport_data_for("sweet", "plat").must_equal(
-                :name => "pipes",
-                key => "datvalue"
-              )
-            end
-
-            it "rejects any value in transport data" do
-              DataMunger.new(
-                {
-                  transport: {
-                    :name => "pipes",
-                    key => "imevil",
-                  },
-                  platforms: [
-                    { name: "plat" },
-                  ],
-                  suites: [
-                    { name: "sweet" },
-                  ],
-                },
-                {}
-              ).transport_data_for("sweet", "plat").must_equal(
-                name: "pipes"
-              )
-            end
-          end
-        end
-      end
-    end
-
-    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_data_for("suite", "platform").must_equal(
-            name: "starship"
-          )
-        end
-
-        it "merges driver into driver_plugin if driver exists" do
-          DataMunger.new(
-            {
-              driver_plugin: "starship",
-              driver: "zappa",
-            },
-            {}
-          ).driver_data_for("suite", "platform").must_equal(
-            name: "zappa"
-          )
-        end
-
-        it "returns common driver config" do
-          DataMunger.new(
-            {
-              driver_plugin: "starship",
-              driver_config: {
-                speed: 42,
-              },
-            },
-            {}
-          ).driver_data_for("suite", "platform").must_equal(
-            name: "starship",
-            speed: 42
-          )
-        end
-
-        it "merges driver into driver_config if driver with name exists" do
-          DataMunger.new(
-            {
-              driver_config: {
-                eh: "yep",
-              },
-              driver: "zappa",
-            },
-            {}
-          ).driver_data_for("suite", "platform").must_equal(
-            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: {
-                name: "zappa",
-                color: "black",
-              },
-            },
-            {}
-          ).driver_data_for("suite", "platform").must_equal(
-            name: "zappa",
-            eh: "yep",
-            color: "black"
-          )
-        end
-
-        it "returns platform driver name" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  driver_plugin: "flip",
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("suite", "plat").must_equal(
-            name: "flip"
-          )
-        end
-
-        it "returns platform config containing driver hash" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  driver_plugin: "flip",
-                  driver_config: {
-                    flop: "yep",
-                  },
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("suite", "plat").must_equal(
-            name: "flip",
-            flop: "yep"
-          )
-        end
-
-        it "returns suite driver name" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  driver_plugin: "waz",
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("sweet", "platform").must_equal(
-            name: "waz"
-          )
-        end
-
-        it "returns suite config containing driver hash" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  driver_plugin: "waz",
-                  driver_config: {
-                    up: "nope",
-                  },
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("sweet", "platform").must_equal(
-            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" },
-              },
-              platforms: [
-                {
-                  name: "plat",
-                  driver_plugin: "platformy",
-                  driver_config: {
-                    fruit: ["banana"],
-                    deep: { platform: "stuff" },
-                  },
-                },
-              ],
-              suites: [
-                {
-                  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",
-            }
-          )
-        end
-
-        it "platform into common" do
-          DataMunger.new(
-            {
-              driver_plugin: "commony",
-              driver_config: {
-                color: "purple",
-                fruit: %w{apple pear},
-                deep: { common: "junk" },
-              },
-              platforms: [
-                {
-                  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",
-            }
-          )
-        end
-
-        it "suite into common" do
-          DataMunger.new(
-            {
-              driver_plugin: "commony",
-              driver_config: {
-                color: "purple",
-                fruit: %w{apple pear},
-                deep: { common: "junk" },
-              },
-              suites: [
-                {
-                  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",
-            }
-          )
-        end
-
-        it "suite into platform" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  driver_plugin: "platformy",
-                  driver_config: {
-                    fruit: ["banana"],
-                    deep: { platform: "stuff" },
-                  },
-                },
-              ],
-              suites: [
-                {
-                  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",
-            }
-          )
-        end
-      end
-    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: [
-                {
-                  :name => "sweet",
-                  key => "mypath",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            key => "mypath"
-          )
-        end
-
-        it "merges provisioner into data_path if provisioner exists" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  :name => "sweet",
-                  key => "mypath",
-                  :provisioner => "chefy",
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "plat").must_equal(
-            :name => "chefy",
-            key => "mypath"
-          )
-        end
-      end
-    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_data_for("suite", "platform").must_equal(
-            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",
-              },
-              driver: {
-                name: "starship",
-                require_chef_omnibus: "dragons",
-              },
-            },
-            {}
-          ).provisioner_data_for("suite", "platform").must_equal(
-            name: "chefy",
-            require_chef_omnibus: "it's probably fine"
-          )
-        end
-
-        it "suite driver value moves into provisioner" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  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"
-          )
-        end
-
-        it "suite driver value loses to existing provisioner value" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: {
-                    name: "chefy",
-                    require_chef_omnibus: "it's probably fine",
-                  },
-                  driver: {
-                    name: "starship",
-                    require_chef_omnibus: "dragons",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "platform").must_equal(
-            name: "chefy",
-            require_chef_omnibus: "it's probably fine"
-          )
-        end
-
-        it "platform driver value moves into provisioner" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  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"
-          )
-        end
-
-        it "platform driver value loses to existing provisioner value" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  provisioner: {
-                    name: "chefy",
-                    require_chef_omnibus: "it's probably fine",
-                  },
-                  driver: {
-                    name: "starship",
-                    require_chef_omnibus: "dragons",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("suite", "plat").must_equal(
-            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",
-              },
-            },
-            {}
-          ).driver_data_for("suite", "platform").must_equal(
-            name: "starship",
-            http_proxy: "http://proxy",
-            https_proxy: "https://proxy"
-          )
-        end
-
-        it "common driver value copies into provisioner" do
-          DataMunger.new(
-            {
-              provisioner: "chefy",
-              driver: {
-                name: "starship",
-                http_proxy: "http://proxy",
-                https_proxy: "https://proxy",
-              },
-            },
-            {}
-          ).provisioner_data_for("suite", "platform").must_equal(
-            name: "chefy",
-            http_proxy: "http://proxy",
-            https_proxy: "https://proxy"
-          )
-        end
-
-        it "common driver value copies into verifier" do
-          DataMunger.new(
-            {
-              verifier: "bussy",
-              driver: {
-                name: "starship",
-                http_proxy: "http://proxy",
-                https_proxy: "https://proxy",
-              },
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "bussy",
-            http_proxy: "http://proxy",
-            https_proxy: "https://proxy"
-          )
-        end
-
-        it "common driver value loses to existing provisioner value" do
-          DataMunger.new(
-            {
-              provisioner: {
-                name: "chefy",
-                http_proxy: "it's probably fine",
-                https_proxy: "la quinta",
-              },
-              driver: {
-                name: "starship",
-                http_proxy: "dragons",
-                https_proxy: "cats",
-              },
-            },
-            {}
-          ).provisioner_data_for("suite", "platform").must_equal(
-            name: "chefy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "common driver value loses to existing verifier value" do
-          DataMunger.new(
-            {
-              verifier: {
-                name: "bussy",
-                http_proxy: "it's probably fine",
-                https_proxy: "la quinta",
-              },
-              driver: {
-                name: "starship",
-                http_proxy: "dragons",
-                https_proxy: "cats",
-              },
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "bussy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "suite driver value remains in driver" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: "chefy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("sweet", "platform").must_equal(
-            name: "starship",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "suite driver value copies into provisioner" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: "chefy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "platform").must_equal(
-            name: "chefy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "suite driver value copies into verifier" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  verifier: "bussy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "platform").must_equal(
-            name: "bussy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "suite driver value loses to existing provisioner value" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  provisioner: {
-                    name: "chefy",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                  driver: {
-                    name: "starship",
-                    http_proxy: "dragons",
-                    https_proxy: "cats",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("sweet", "platform").must_equal(
-            name: "chefy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "suite driver value loses to existing verifier value" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  verifier: {
-                    name: "bussy",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                  driver: {
-                    name: "starship",
-                    http_proxy: "dragons",
-                    https_proxy: "cats",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "platform").must_equal(
-            name: "bussy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "platform driver value remains in driver" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  provisioner: "chefy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).driver_data_for("suite", "plat").must_equal(
-            name: "starship",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "platform driver value copies into provisioner" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  provisioner: "chefy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("suite", "plat").must_equal(
-            name: "chefy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "platform driver value copies into verifier" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  verifier: "bussy",
-                  driver: {
-                    name: "starship",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("suite", "plat").must_equal(
-            name: "bussy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "platform driver value loses to existing provisioner value" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  provisioner: {
-                    name: "chefy",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                  driver: {
-                    name: "starship",
-                    http_proxy: "dragons",
-                    https_proxy: "cats",
-                  },
-                },
-              ],
-            },
-            {}
-          ).provisioner_data_for("suite", "plat").must_equal(
-            name: "chefy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-
-        it "platform driver value loses to existing verifier value" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  verifier: {
-                    name: "bussy",
-                    http_proxy: "it's probably fine",
-                    https_proxy: "la quinta",
-                  },
-                  driver: {
-                    name: "starship",
-                    http_proxy: "dragons",
-                    https_proxy: "cats",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("suite", "plat").must_equal(
-            name: "bussy",
-            http_proxy: "it's probably fine",
-            https_proxy: "la quinta"
-          )
-        end
-      end
-    end
-
-    describe "legacy busser blocks to verifier" do
-      describe "from a single source" do
-        it "merges old common busser name to version into verifier" do
-          DataMunger.new(
-            {
-              busser: "starship",
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "busser",
-            version: "starship"
-          )
-        end
-
-        it "merges old common busser name to version with exising verifier" do
-          DataMunger.new(
-            {
-              busser: "starship",
-              verifier: {
-                a: "b",
-              },
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "busser",
-            version: "starship",
-            a: "b"
-          )
-        end
-
-        it "merges old common busser name to version into verifier with name" do
-          DataMunger.new(
-            {
-              busser: "starship",
-              verifier: "stellar",
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "stellar",
-            version: "starship"
-          )
-        end
-
-        it "merges old busser data into verifier with name" do
-          DataMunger.new(
-            {
-              busser: {
-                a: "b",
-              },
-              verifier: "stellar",
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "stellar",
-            a: "b"
-          )
-        end
-
-        it "merges old busser data into verifier data" do
-          DataMunger.new(
-            {
-              busser: {
-                a: "b",
-                both: "legacy",
-              },
-              verifier: {
-                name: "stellar",
-                c: "d",
-                both: "modern",
-              },
-            },
-            {}
-          ).verifier_data_for("suite", "platform").must_equal(
-            name: "stellar",
-            a: "b",
-            c: "d",
-            both: "modern"
-          )
-        end
-
-        it "returns platform verifier name" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  busser: "flip",
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("suite", "plat").must_equal(
-            name: "busser",
-            version: "flip"
-          )
-        end
-
-        it "return platform config containing verifier hash" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  busser: "flip",
-                  verifier: {
-                    flop: "yep",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("suite", "plat").must_equal(
-            name: "busser",
-            version: "flip",
-            flop: "yep"
-          )
-        end
-
-        it "returns suite driver name" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  busser: "waz",
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "platform").must_equal(
-            name: "busser",
-            version: "waz"
-          )
-        end
-
-        it "returns suite config containing verifier hash" do
-          DataMunger.new(
-            {
-              suites: [
-                {
-                  name: "sweet",
-                  busser: "waz",
-                  verifier: {
-                    up: "nope",
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "platform").must_equal(
-            name: "busser",
-            version: "waz",
-            up: "nope"
-          )
-        end
-      end
-
-      describe "from multiple sources" do
-        it "suite into platform into common" do
-          DataMunger.new(
-            {
-              busser: {
-                version: "commony",
-                color: "purple",
-                fruit: %w{apple pear},
-                deep: { common: "junk" },
-              },
-              platforms: [
-                {
-                  name: "plat",
-                  busser: {
-                    version: "platformy",
-                    fruit: ["banana"],
-                    deep: { platform: "stuff" },
-                  },
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  busser: {
-                    version: "suitey",
-                    vehicle: "car",
-                    deep: { suite: "things" },
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "plat").must_equal(
-            name: "busser",
-            version: "suitey",
-            color: "purple",
-            fruit: ["banana"],
-            vehicle: "car",
-            deep: {
-              common: "junk",
-              platform: "stuff",
-              suite: "things",
-            }
-          )
-        end
-
-        it "platform into common" do
-          DataMunger.new(
-            {
-              busser: {
-                version: "commony",
-                color: "purple",
-                fruit: %w{apple pear},
-                deep: { common: "junk" },
-              },
-              platforms: [
-                {
-                  name: "plat",
-                  busser: {
-                    version: "platformy",
-                    fruit: ["banana"],
-                    deep: { platform: "stuff" },
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "plat").must_equal(
-            name: "busser",
-            version: "platformy",
-            color: "purple",
-            fruit: ["banana"],
-            deep: {
-              common: "junk",
-              platform: "stuff",
-            }
-          )
-        end
-
-        it "suite into common" do
-          DataMunger.new(
-            {
-              busser: {
-                version: "commony",
-                color: "purple",
-                fruit: %w{apple pear},
-                deep: { common: "junk" },
-              },
-              suites: [
-                {
-                  name: "sweet",
-                  busser: {
-                    version: "suitey",
-                    vehicle: "car",
-                    deep: { suite: "things" },
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "plat").must_equal(
-            name: "busser",
-            version: "suitey",
-            color: "purple",
-            fruit: %w{apple pear},
-            vehicle: "car",
-            deep: {
-              common: "junk",
-              suite: "things",
-            }
-          )
-        end
-
-        it "suite into platform" do
-          DataMunger.new(
-            {
-              platforms: [
-                {
-                  name: "plat",
-                  busser: {
-                    version: "platformy",
-                    fruit: ["banana"],
-                    deep: { platform: "stuff" },
-                  },
-                },
-              ],
-              suites: [
-                {
-                  name: "sweet",
-                  busser: {
-                    version: "suitey",
-                    vehicle: "car",
-                    deep: { suite: "things" },
-                  },
-                },
-              ],
-            },
-            {}
-          ).verifier_data_for("sweet", "plat").must_equal(
-            name: "busser",
-            version: "suitey",
-            fruit: ["banana"],
-            vehicle: "car",
-            deep: {
-              platform: "stuff",
-              suite: "things",
-            }
-          )
-        end
-      end
-    end
-
-    describe "lifecycle_hooks stuff" do
-      it "handles a single global hook" do
-        DataMunger.new(
-          {
-            lifecycle: {
-              pre_create: "echo foo",
-            },
-            platforms: [{ name: "plat" }],
-            suites: [{ name: "sweet" }],
-          },
-          {}
-        ).lifecycle_hooks_data_for("sweet", "plat").must_equal(
-          pre_create: ["echo foo"]
-        )
-      end
-
-      it "handles multiple global hooks" do
-        DataMunger.new(
-          {
-            lifecycle: {
-              pre_create: "echo foo",
-              post_converge: ["echo bar", { local: "echo baz" }],
-              pre_verify: [{ remote: "echo other" }],
-            },
-            platforms: [{ name: "plat" }],
-            suites: [{ name: "sweet" }],
-          },
-          {}
-        ).lifecycle_hooks_data_for("sweet", "plat").must_equal(
-          pre_create: ["echo foo"],
-          post_converge: ["echo bar", { local: "echo baz" }],
-          pre_verify: [{ remote: "echo other" }]
-        )
-      end
-
-      it "handles hooks in platforms and suites" do
-        DataMunger.new(
-          {
-            lifecycle: {
-              pre_create: "echo foo",
-              post_create: "echo post",
-            },
-            platforms: [{
-              name: "plat",
-              lifecycle: {
-                pre_create: "echo bar",
-              },
-            }],
-            suites: [{
-              name: "sweet",
-              lifecycle: {
-                pre_create: "echo baz",
-              },
-            }],
-          },
-          {}
-        ).lifecycle_hooks_data_for("sweet", "plat").must_equal(
-          pre_create: ["echo foo", "echo bar", "echo baz"],
-          post_create: ["echo post"]
-        )
-      end
-
-      it "munges a global legacy pre_create_command" do
-        DataMunger.new(
-          {
-            driver: {
-              pre_create_command: "echo bar",
-            },
-            lifecycle: {
-              pre_create: "echo foo",
-            },
-            platforms: [{ name: "plat" }],
-            suites: [{ name: "sweet" }],
-          },
-          {}
-        ).lifecycle_hooks_data_for("sweet", "plat").must_equal(
-          pre_create: ["echo foo", { local: "echo bar" }]
-        )
-      end
-
-      it "munges a platform/suite legacy pre_create_commands" do
-        DataMunger.new(
-          {
-            lifecycle: {
-              pre_create: "echo foo",
-            },
-            platforms: [{
-              name: "plat",
-              driver: {
-                pre_create_command: "echo bar",
-              },
-            }],
-            suites: [{
-              name: "sweet",
-              driver: {
-                pre_create_command: "echo baz",
-              },
-            }],
-          },
-          {}
-        ).lifecycle_hooks_data_for("sweet", "plat").must_equal(
-          pre_create: ["echo foo", { local: "echo bar" }, { local: "echo baz" }]
-        )
-      end
-
-    end
-  end
-end