vagrant-aws-mkubenka 0.7.2.pre.22 → 0.7.2.pre.24

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/vagrant/cli_test.rb

@@ -1,57 +0,0 @@
-require_relative "../base"
-
-require "vagrant/cli"
-
-describe Vagrant::CLI do
-  include_context "unit"
-  include_context "command plugin helpers"
-
-  let(:commands) { {} }
-  let(:iso_env) { isolated_environment }
-  let(:env)     { iso_env.create_vagrant_env }
-
-  before do
-    allow(Vagrant.plugin("2").manager).to receive(:commands).and_return(commands)
-  end
-
-  describe "#execute" do
-    it "invokes help and exits with 1 if invalid command" do
-      subject = described_class.new(["i-dont-exist"], env)
-      expect(subject).to receive(:help).once
-      expect(subject.execute).to eql(1)
-    end
-
-    it "invokes command and returns its exit status if the command is valid" do
-      commands[:destroy] = [command_lambda("destroy", 42), {}]
-
-      subject = described_class.new(["destroy"], env)
-      expect(subject).not_to receive(:help)
-      expect(subject.execute).to eql(42)
-    end
-
-    it "returns exit code 1 if interrupted" do
-      commands[:destroy] = [command_lambda("destroy", 42, exception: Interrupt), {}]
-
-      subject = described_class.new(["destroy"], env)
-      expect(subject.execute).to eql(1)
-    end
-  end
-
-  describe "#help" do
-    subject { described_class.new([], env) }
-
-    it "includes all primary subcommands" do
-      commands[:foo] = [command_lambda("foo", 0), { primary: true }]
-      commands[:bar] = [command_lambda("bar", 0), { primary: true }]
-      commands[:baz] = [command_lambda("baz", 0), { primary: false }]
-
-      expect(env.ui).to receive(:info).with(any_args) { |message, opts|
-        expect(message).to include("foo")
-        expect(message).to include("bar")
-        expect(message.include?("baz")).to be(false)
-      }
-
-      subject.help
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/vagrant/config/loader_test.rb

@@ -1,235 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/registry"
-
-describe Vagrant::Config::Loader do
-  include_context "unit"
-
-  # This is the current version of configuration for the tests.
-  let(:current_version) { version_order.last }
-
-  # This is just a dummy implementation of a configuraiton loader which
-  # simply acts on hashes.
-  let(:test_loader) do
-    Class.new(Vagrant::Config::VersionBase) do
-      def self.init
-        {}
-      end
-
-      def self.load(proc)
-        init.tap do |obj|
-          proc.call(obj)
-        end
-      end
-
-      def self.merge(old, new)
-        old.merge(new) {|key, oldval, newval| oldval.concat(newval)}
-      end
-    end
-  end
-
-  let(:versions) do
-    Vagrant::Registry.new.tap do |r|
-      r.register("1") { test_loader }
-    end
-  end
-
-  let(:version_order) { ["1"] }
-
-  let(:instance) { described_class.new(versions, version_order) }
-
-  describe "#set" do
-    context "with an object that cannot be inspected" do
-
-      # This represents the euro symbol in UTF-16LE. pack("c*") returns an ASCII
-      # string and so we have to force the encoding
-      UTF_16LE_STRING_THAT_CANNOT_BE_DOWNCAST_TO_ASCII = [0x20, 0xAC].pack("c*").force_encoding("UTF-16LE")
-
-
-      let(:klass_with_bad_inspect_string) do
-        Class.new do
-          def inspect
-            UTF_16LE_STRING_THAT_CANNOT_BE_DOWNCAST_TO_ASCII
-          end
-        end
-      end
-
-      let(:test_source) {
-        Class.new do
-          def initialize(collaborator)
-            @foo = collaborator.new
-          end
-        end.new(klass_with_bad_inspect_string)
-      }
-
-      it "does not raise the ascii encoding exception" do
-        expect {
-          instance.set(:arbitrary, test_source)
-        }.to raise_error(ArgumentError, /Unknown configuration source/)
-      end
-    end
-  end
-
-  describe "basic loading" do
-    it "should ignore non-existent load order keys" do
-      instance.load([:foo])
-    end
-
-    it "should load and return the configuration" do
-      proc = Proc.new do |config|
-        config[:foo] = "yep"
-      end
-
-      instance.set(:proc, [[current_version, proc]])
-      config, warnings, errors = instance.load([:proc])
-
-      expect(config[:foo]).to eq("yep")
-      expect(warnings).to eq([])
-      expect(errors).to eq([])
-    end
-  end
-
-  describe "finalization" do
-    it "should finalize the configuration" do
-      # Create the finalize method on our loader
-      def test_loader.finalize(obj)
-        obj[:finalized] = true
-        obj
-      end
-
-      # Basic configuration proc
-      proc = lambda do |config|
-        config[:foo] = "yep"
-      end
-
-      # Run the actual configuration and assert that we get the proper result
-      instance.set(:proc, [[current_version, proc]])
-      config, _ = instance.load([:proc])
-      expect(config[:foo]).to eq("yep")
-      expect(config[:finalized]).to eq(true)
-    end
-  end
-
-  describe "upgrading" do
-    it "should do an upgrade to the latest version" do
-      test_loader_v2 = Class.new(test_loader) do
-        def self.upgrade(old)
-          new = old.dup
-          new[:v2] = true
-
-          [new, [], []]
-        end
-      end
-
-      versions.register("2") { test_loader_v2 }
-      version_order << "2"
-
-      # Load a version 1 proc, and verify it is upgraded to version 2
-      proc = lambda { |config| config[:foo] = "yep" }
-      instance.set(:proc, [["1", proc]])
-      config, _ = instance.load([:proc])
-      expect(config[:foo]).to eq("yep")
-      expect(config[:v2]).to eq(true)
-    end
-
-    it "should keep track of warnings and errors" do
-      test_loader_v2 = Class.new(test_loader) do
-        def self.upgrade(old)
-          new = old.dup
-          new[:v2] = true
-
-          [new, ["foo!"], ["bar!"]]
-        end
-      end
-
-      versions.register("2") { test_loader_v2 }
-      version_order << "2"
-
-      # Load a version 1 proc, and verify it is upgraded to version 2
-      proc = lambda { |config| config[:foo] = "yep" }
-      instance.set(:proc, [["1", proc]])
-      config, warnings, errors = instance.load([:proc])
-      expect(config[:foo]).to eq("yep")
-      expect(config[:v2]).to eq(true)
-      expect(warnings).to eq(["foo!"])
-      expect(errors).to eq(["bar!"])
-    end
-  end
-
-  describe "loading edge cases" do
-    it "should only run the same proc once" do
-      count = 0
-      proc = Proc.new do |config|
-        config[:foo] = "yep"
-        count += 1
-      end
-
-      instance.set(:proc, [[current_version, proc]])
-
-      5.times do
-        result, _ = instance.load([:proc])
-
-        # Verify the config result
-        expect(result[:foo]).to eq("yep")
-
-        # Verify the count is only one
-        expect(count).to eq(1)
-      end
-    end
-
-    it "should discard duplicate configs if :home and :root are the same" do
-      proc = Proc.new do |config|
-        config[:foo] = ["yep"]
-      end
-
-      order = [:root, :home]
-
-      instance.set(:root, [[current_version, proc]])
-      instance.set(:home, [[current_version, proc]])
-
-      result, warnings, errors = instance.load(order)
-
-      # Verify the config result
-      expect(result[:foo]).to eq(["yep"])
-      expect(result[:foo].size).to eq(1)
-      expect(warnings).to eq([])
-      expect(errors).to eq([])
-    end
-
-    it "should only load configuration files once" do
-      $_config_data = 0
-
-      # We test both setting a file multiple times as well as multiple
-      # loads, since both should not cache the data.
-      file = temporary_file("$_config_data += 1")
-      5.times { instance.set(:file, file) }
-      5.times { instance.load([:file]) }
-
-      expect($_config_data).to eq(1)
-    end
-
-    it "should not clear the cache if setting to the same value multiple times" do
-      $_config_data = 0
-
-      file = temporary_file("$_config_data += 1")
-
-      instance.set(:proc, file)
-      5.times { instance.load([:proc]) }
-
-      instance.set(:proc, file)
-      5.times { instance.load([:proc]) }
-
-      expect($_config_data).to eq(1)
-    end
-
-    it "should raise proper error if there is a syntax error in a Vagrantfile" do
-      expect { instance.set(:file, temporary_file("Vagrant:^Config")) }.
-        to raise_exception(Vagrant::Errors::VagrantfileSyntaxError)
-    end
-
-    it "should raise a proper error if there is a problem with the Vagrantfile" do
-      expect { instance.set(:file, temporary_file("foo")) }.
-        to raise_exception(Vagrant::Errors::VagrantfileLoadError)
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/vagrant/config/v2/root_test.rb

@@ -1,126 +0,0 @@
-require "set"
-
-require File.expand_path("../../../../base", __FILE__)
-
-describe Vagrant::Config::V2::Root do
-  include_context "unit"
-
-  it "should provide access to config objects" do
-    foo_class = Class.new
-    map       = { foo: foo_class }
-
-    instance  = described_class.new(map)
-    foo       = instance.foo
-    expect(foo).to be_kind_of(foo_class)
-    expect(instance.foo).to eql(foo)
-  end
-
-  it "record a missing key call if invalid key used" do
-    instance = described_class.new({})
-    expect { instance.foo }.to_not raise_error
-    expect(instance.__internal_state["missing_key_calls"].include?("foo")).to be
-  end
-
-  it "returns a dummy config for a missing key" do
-    instance = described_class.new({})
-    expect { instance.foo.foo = "bar" }.to_not raise_error
-  end
-
-  it "can be created with initial state" do
-    instance = described_class.new({}, { foo: "bar" })
-    expect(instance.foo).to eq("bar")
-  end
-
-  it "should return internal state" do
-    map      = { "foo" => Object, "bar" => Object }
-    instance = described_class.new(map)
-    expect(instance.__internal_state).to eq({
-      "config_map"        => map,
-      "keys"              => {},
-      "missing_key_calls" => Set.new
-    })
-  end
-
-  describe "#finalize!" do
-    it "should call #finalize!" do
-      foo_class = Class.new(Vagrant.plugin("2", "config")) do
-        attr_accessor :foo
-
-        def finalize!
-          @foo = "SET"
-        end
-      end
-
-      map = { foo: foo_class }
-      instance = described_class.new(map)
-      instance.finalize!
-
-      expect(instance.foo.foo).to eq("SET")
-    end
-
-    it "should call #_finalize!" do
-      klass = Class.new(Vagrant.plugin("2", "config"))
-
-      expect_any_instance_of(klass).to receive(:finalize!)
-      expect_any_instance_of(klass).to receive(:_finalize!)
-
-      map = { foo: klass }
-      instance = described_class.new(map)
-      instance.finalize!
-    end
-  end
-
-  describe "validation" do
-    let(:instance) do
-      map = { foo: Object, bar: Object }
-      described_class.new(map)
-    end
-
-    it "should return nil if valid" do
-      expect(instance.validate({})).to eq({})
-    end
-
-    it "should return errors if invalid" do
-      errors = { "foo" => ["errors!"] }
-      env    = { "errors" => errors }
-      foo    = instance.foo
-      def foo.validate(env)
-        env["errors"]
-      end
-
-      expect(instance.validate(env)).to eq(errors)
-    end
-
-    it "should merge errors via array concat if matching keys" do
-      errors = { "foo" => ["errors!"] }
-      env    = { "errors" => errors }
-      foo    = instance.foo
-      bar    = instance.bar
-      def foo.validate(env)
-        env["errors"]
-      end
-
-      def bar.validate(env)
-        env["errors"].merge({ "bar" => ["bar"] })
-      end
-
-      expected_errors = {
-        "foo" => ["errors!", "errors!"],
-        "bar" => ["bar"]
-      }
-
-      expect(instance.validate(env)).to eq(expected_errors)
-    end
-
-    it "shouldn't count empty keys" do
-      errors = { "foo" => [] }
-      env    = { "errors" => errors }
-      foo    = instance.foo
-      def foo.validate(env)
-        env["errors"]
-      end
-
-      expect(instance.validate(env)).to eq({})
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/bundler/gems/vagrant-f3fdbf414272/test/unit/vagrant/environment_test.rb

@@ -1,1433 +0,0 @@
-require File.expand_path("../../base", __FILE__)
-require "json"
-require "pathname"
-require "tempfile"
-require "tmpdir"
-
-require "vagrant/util/file_mode"
-require "vagrant/util/platform"
-
-describe Vagrant::Environment do
-  include_context "unit"
-  include_context "capability_helpers"
-
-  let(:env) do
-    isolated_environment.tap do |e|
-      e.box3("base", "1.0", :virtualbox)
-      e.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vm.box = "base"
-      end
-      VF
-    end
-  end
-
-  let(:instance)  { env.create_vagrant_env }
-  subject { instance }
-
-  describe "#can_install_provider?" do
-    let(:plugin_hosts) { {} }
-    let(:plugin_host_caps) { {} }
-
-    before do
-      m = Vagrant.plugin("2").manager
-      allow(m).to receive(:hosts).and_return(plugin_hosts)
-      allow(m).to receive(:host_capabilities).and_return(plugin_host_caps)
-
-      # Detect the host
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = nil
-      end
-      VF
-
-      # Setup the foo host by default
-      plugin_hosts[:foo] = [detect_class(true), nil]
-    end
-
-    it "should return whether it can install or not" do
-      plugin_host_caps[:foo] = { provider_install_foo: Class }
-
-      expect(subject.can_install_provider?(:foo)).to be(true)
-      expect(subject.can_install_provider?(:bar)).to be(false)
-    end
-  end
-
-  describe "#install_provider" do
-    let(:host) { double(:host) }
-
-    before do
-      allow(subject).to receive(:host).and_return(host)
-    end
-
-    it "should install the correct provider" do
-      expect(host).to receive(:capability).with(:provider_install_foo)
-
-      subject.install_provider(:foo)
-    end
-  end
-
-  describe "#gems_path" do
-    it "is set to Vagrant::Bundler defined path" do
-      instance = described_class.new
-      expect(instance.gems_path).to eq(Vagrant::Bundler.instance.plugin_gem_path)
-    end
-  end
-
-  describe "#home_path" do
-    it "is set to the home path given" do
-      Dir.mktmpdir("vagrant-test-env-home-path-given") do |dir|
-        instance = described_class.new(home_path: dir)
-        expect(instance.home_path).to eq(Pathname.new(dir))
-      end
-    end
-
-    it "is set to the environmental variable VAGRANT_HOME" do
-      Dir.mktmpdir("vagrant-test-env-home-env-var") do |dir|
-        instance = with_temp_env("VAGRANT_HOME" => dir.to_s) do
-          described_class.new
-        end
-
-        expect(instance.home_path).to eq(Pathname.new(dir))
-      end
-    end
-
-    it "throws an exception if inaccessible", skip_windows: true do
-      expect {
-        described_class.new(home_path: "/")
-      }.to raise_error(Vagrant::Errors::HomeDirectoryNotAccessible)
-    end
-
-    context "with setup version file" do
-      it "creates a setup version flie" do
-        path = subject.home_path.join("setup_version")
-        expect(path).to be_file
-        expect(path.read).to eq(Vagrant::Environment::CURRENT_SETUP_VERSION)
-      end
-
-      it "is okay if it has the current version" do
-        Dir.mktmpdir("vagrant-test-env-current-version") do |dir|
-          Pathname.new(dir).join("setup_version").open("w") do |f|
-            f.write(Vagrant::Environment::CURRENT_SETUP_VERSION)
-          end
-
-          instance = described_class.new(home_path: dir)
-          path = instance.home_path.join("setup_version")
-          expect(path).to be_file
-          expect(path.read).to eq(Vagrant::Environment::CURRENT_SETUP_VERSION)
-        end
-      end
-
-      it "raises an exception if the version is newer than ours" do
-        Dir.mktmpdir("vagrant-test-env-newer-version") do |dir|
-          Pathname.new(dir).join("setup_version").open("w") do |f|
-            f.write("100.5")
-          end
-
-          expect { described_class.new(home_path: dir) }.
-            to raise_error(Vagrant::Errors::HomeDirectoryLaterVersion)
-        end
-      end
-
-      it "raises an exception if there is an unknown home directory version" do
-        Dir.mktmpdir("vagrant-test-env-unknown-home") do |dir|
-          Pathname.new(dir).join("setup_version").open("w") do |f|
-            f.write("0.7")
-          end
-
-          expect { described_class.new(home_path: dir) }.
-            to raise_error(Vagrant::Errors::HomeDirectoryUnknownVersion)
-        end
-      end
-    end
-
-    context "upgrading a v1.1 directory structure" do
-      let(:env) { isolated_environment }
-
-      before do
-        env.homedir.join("setup_version").open("w") do |f|
-          f.write("1.1")
-        end
-
-        allow_any_instance_of(Vagrant::UI::Silent).
-          to receive(:ask)
-      end
-
-      it "replaces the setup version with the new version" do
-        expect(subject.home_path.join("setup_version").read).
-          to eq(Vagrant::Environment::CURRENT_SETUP_VERSION)
-      end
-
-      it "moves the boxes into the new directory structure" do
-        # Kind of hacky but avoids two instantiations of BoxCollection
-        allow(Vagrant::Environment).to receive(:boxes)
-          .and_return(double("boxes"))
-
-        collection = double("collection")
-        expect(Vagrant::BoxCollection).to receive(:new).with(
-          env.homedir.join("boxes"), anything).and_return(collection)
-        expect(collection).to receive(:upgrade_v1_1_v1_5).once
-        subject
-      end
-    end
-  end
-
-  describe "#host" do
-    let(:plugin_hosts) { {} }
-    let(:plugin_host_caps) { {} }
-
-    before do
-      m = Vagrant.plugin("2").manager
-      allow(m).to receive(:hosts).and_return(plugin_hosts)
-      allow(m).to receive(:host_capabilities).and_return(plugin_host_caps)
-    end
-
-    it "should default to some host even if there are none" do
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = nil
-      end
-      VF
-
-      expect(subject.host).to be
-    end
-
-    it "should attempt to detect a host if no host is set" do
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = nil
-      end
-      VF
-
-      plugin_hosts[:foo] = [detect_class(true), nil]
-      plugin_host_caps[:foo] = { bar: Class }
-
-      result = subject.host
-      expect(result.capability?(:bar)).to be(true)
-    end
-
-    it "should attempt to detect a host if host is :detect" do
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = :detect
-      end
-      VF
-
-      plugin_hosts[:foo] = [detect_class(true), nil]
-      plugin_host_caps[:foo] = { bar: Class }
-
-      result = subject.host
-      expect(result.capability?(:bar)).to be(true)
-    end
-
-    it "should use an exact host if specified" do
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = "foo"
-      end
-      VF
-
-      plugin_hosts[:foo] = [detect_class(false), nil]
-      plugin_hosts[:bar] = [detect_class(true), nil]
-      plugin_host_caps[:foo] = { bar: Class }
-
-      result = subject.host
-      expect(result.capability?(:bar)).to be(true)
-    end
-
-    it "should raise an error if an exact match was specified but not found" do
-      env.vagrantfile <<-VF
-      Vagrant.configure("2") do |config|
-        config.vagrant.host = "bar"
-      end
-      VF
-
-      expect { subject.host }.
-        to raise_error(Vagrant::Errors::HostExplicitNotDetected)
-    end
-  end
-
-  describe "#lock" do
-    def lock_count
-      subject.data_dir.
-        children.
-        find_all { |c| c.to_s.end_with?("lock") }.
-        length
-    end
-
-    it "does nothing if no block is given" do
-      subject.lock
-    end
-
-    it "locks the environment" do
-      another = env.create_vagrant_env
-      raised  = false
-
-      subject.lock do
-        begin
-          another.lock {}
-        rescue Vagrant::Errors::EnvironmentLockedError
-          raised = true
-        end
-      end
-
-      expect(raised).to be(true)
-    end
-
-    it "allows nested locks on the same environment" do
-      success = false
-
-      subject.lock do
-        subject.lock do
-          success = true
-        end
-      end
-
-      expect(success).to be(true)
-    end
-
-    it "cleans up all lock files" do
-      inner_count = nil
-
-      expect(lock_count).to eq(0)
-      subject.lock do
-        inner_count = lock_count
-      end
-
-      expect(inner_count).to_not be_nil
-      expect(inner_count).to eq(2)
-      expect(lock_count).to eq(1)
-    end
-  end
-
-  describe "#machine" do
-    # A helper to register a provider for use in tests.
-    def register_provider(name, config_class=nil, options=nil)
-      provider_cls = Class.new(VagrantTests::DummyProvider)
-
-      register_plugin("2") do |p|
-        p.provider(name, options) { provider_cls }
-
-        if config_class
-          p.config(name, :provider) { config_class }
-        end
-      end
-
-      provider_cls
-    end
-
-    it "should return a machine object with the correct provider" do
-      # Create a provider
-      foo_provider = register_provider("foo")
-
-      # Create the configuration
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.define "foo"
-end
-VF
-
-        e.box3("base", "1.0", :foo)
-      end
-
-      # Verify that we can get the machine
-      env = isolated_env.create_vagrant_env
-      machine = env.machine(:foo, :foo)
-      expect(machine).to be_kind_of(Vagrant::Machine)
-      expect(machine.name).to eq(:foo)
-      expect(machine.provider).to be_kind_of(foo_provider)
-      expect(machine.provider_config).to be_nil
-    end
-
-    it "should return a machine object with the machine configuration" do
-      # Create a provider
-      foo_config = Class.new(Vagrant.plugin("2", :config)) do
-        attr_accessor :value
-      end
-
-      foo_provider = register_provider("foo", foo_config)
-
-      # Create the configuration
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.define "foo"
-
-  config.vm.provider :foo do |fooconfig|
-    fooconfig.value = 100
-  end
-end
-VF
-
-        e.box3("base", "1.0", :foo)
-      end
-
-      # Verify that we can get the machine
-      env = isolated_env.create_vagrant_env
-      machine = env.machine(:foo, :foo)
-      expect(machine).to be_kind_of(Vagrant::Machine)
-      expect(machine.name).to eq(:foo)
-      expect(machine.provider).to be_kind_of(foo_provider)
-      expect(machine.provider_config.value).to eq(100)
-    end
-
-    it "should cache the machine objects by name and provider" do
-      # Create a provider
-      foo_provider = register_provider("foo")
-      bar_provider = register_provider("bar")
-
-      # Create the configuration
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.define "vm1"
-  config.vm.define "vm2"
-end
-VF
-
-        e.box3("base", "1.0", :foo)
-        e.box3("base", "1.0", :bar)
-      end
-
-      env = isolated_env.create_vagrant_env
-      vm1_foo = env.machine(:vm1, :foo)
-      vm1_bar = env.machine(:vm1, :bar)
-      vm2_foo = env.machine(:vm2, :foo)
-
-      expect(vm1_foo).to eql(env.machine(:vm1, :foo))
-      expect(vm1_bar).to eql(env.machine(:vm1, :bar))
-      expect(vm1_foo).not_to eql(vm1_bar)
-      expect(vm2_foo).to eql(env.machine(:vm2, :foo))
-    end
-
-    it "should load a machine without a box" do
-      register_provider("foo")
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "i-dont-exist"
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:default, :foo)
-      expect(machine.box).to be_nil
-    end
-
-    it "should load the machine configuration" do
-      register_provider("foo")
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 1
-  config.vm.box = "base"
-
-  config.vm.define "vm1" do |inner|
-    inner.ssh.port = 100
-  end
-end
-VF
-
-        env.box3("base", "1.0", :foo)
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:vm1, :foo)
-      expect(machine.config.ssh.port).to eq(100)
-      expect(machine.config.vm.box).to eq("base")
-    end
-
-    it "should load the box configuration for a box" do
-      register_provider("foo")
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-end
-VF
-
-        env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 100
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:default, :foo)
-      expect(machine.config.ssh.port).to eq(100)
-    end
-
-    it "should load the box configuration for a box and custom Vagrantfile name" do
-      register_provider("foo")
-
-      environment = isolated_environment do |env|
-        env.file("some_other_name", <<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-end
-VF
-
-        env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 100
-end
-VF
-      end
-
-      env = with_temp_env("VAGRANT_VAGRANTFILE" => "some_other_name") do
-        environment.create_vagrant_env
-      end
-
-      machine = env.machine(:default, :foo)
-      expect(machine.config.ssh.port).to eq(100)
-    end
-
-    it "should load the box configuration for other formats for a box" do
-      register_provider("foo", nil, box_format: "bar")
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-end
-VF
-
-        env.box3("base", "1.0", :bar, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 100
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:default, :foo)
-      expect(machine.config.ssh.port).to eq(100)
-    end
-
-    it "prefer sooner formats when multiple box formats are available" do
-      register_provider("foo", nil, box_format: ["fA", "fB"])
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-end
-VF
-
-        env.box3("base", "1.0", :fA, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 100
-end
-VF
-
-        env.box3("base", "1.0", :fB, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 200
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:default, :foo)
-      expect(machine.config.ssh.port).to eq(100)
-    end
-
-    it "should load the proper version of a box" do
-      register_provider("foo")
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.box_version = "~> 1.2"
-end
-VF
-
-        env.box3("base", "1.0", :foo, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 100
-end
-VF
-
-        env.box3("base", "1.5", :foo, vagrantfile: <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 200
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      machine = env.machine(:default, :foo)
-      expect(machine.config.ssh.port).to eq(200)
-    end
-
-    it "should load the provider override if set" do
-      register_provider("bar")
-      register_provider("foo")
-
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "foo"
-
-  config.vm.provider :foo do |_, c|
-    c.vm.box = "bar"
-  end
-end
-VF
-      end
-
-      env = isolated_env.create_vagrant_env
-      foo_vm = env.machine(:default, :foo)
-      bar_vm = env.machine(:default, :bar)
-      expect(foo_vm.config.vm.box).to eq("bar")
-      expect(bar_vm.config.vm.box).to eq("foo")
-    end
-
-    it "should reload the cache if refresh is set" do
-      # Create a provider
-      foo_provider = register_provider("foo")
-
-      # Create the configuration
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-end
-VF
-
-        e.box3("base", "1.0", :foo)
-      end
-
-      env = isolated_env.create_vagrant_env
-      vm1 = env.machine(:default, :foo)
-      vm2 = env.machine(:default, :foo, true)
-      vm3 = env.machine(:default, :foo)
-
-      expect(vm1).not_to eql(vm2)
-      expect(vm2).to eql(vm3)
-    end
-
-    it "should raise an error if the VM is not found" do
-      expect { instance.machine("i-definitely-dont-exist", :virtualbox) }.
-        to raise_error(Vagrant::Errors::MachineNotFound)
-    end
-
-    it "should raise an error if the provider is not found" do
-      expect { instance.machine(:default, :lol_no) }.
-        to raise_error(Vagrant::Errors::ProviderNotFound)
-    end
-  end
-
-  describe "#machine_index" do
-    it "returns a machine index" do
-      expect(subject.machine_index).to be_kind_of(Vagrant::MachineIndex)
-    end
-
-    it "caches the result" do
-      result = subject.machine_index
-      expect(subject.machine_index).to equal(result)
-    end
-
-    it "uses a directory within the home directory by default" do
-      klass = double("machine_index")
-      stub_const("Vagrant::MachineIndex", klass)
-
-      expect(klass).to receive(:new).with(any_args) do |path|
-        expect(path.to_s.start_with?(subject.home_path.to_s)).to be(true)
-        true
-      end
-
-      subject.machine_index
-    end
-  end
-
-  describe "active machines" do
-    it "should be empty if there is no root path" do
-      Dir.mktmpdir("vagrant-test-env-no-root-path") do |temp_dir|
-        instance = described_class.new(cwd: temp_dir)
-        expect(instance.active_machines).to be_empty
-      end
-    end
-
-    it "should be empty if the machines folder doesn't exist" do
-      folder = instance.local_data_path.join("machines")
-      expect(folder).not_to be_exist
-
-      expect(instance.active_machines).to be_empty
-    end
-
-    it "should return the name and provider of active machines" do
-      machines = instance.local_data_path.join("machines")
-
-      # Valid machine, with "foo" and virtualbox
-      machine_foo = machines.join("foo/virtualbox")
-      machine_foo.mkpath
-      machine_foo.join("id").open("w+") { |f| f.write("") }
-
-      # Invalid machine (no ID)
-      machine_bar = machines.join("bar/virtualbox")
-      machine_bar.mkpath
-
-      expect(instance.active_machines).to eq([[:foo, :virtualbox]])
-    end
-  end
-
-  describe "batching" do
-    let(:batch) do
-      double("batch") do |b|
-        allow(b).to receive(:run)
-      end
-    end
-
-    context "without the disabling env var" do
-      it "should run without disabling parallelization" do
-        with_temp_env("VAGRANT_NO_PARALLEL" => nil) do
-          expect(Vagrant::BatchAction).to receive(:new).with(true).and_return(batch)
-          expect(batch).to receive(:run)
-
-          instance.batch {}
-        end
-      end
-
-      it "should run with disabling parallelization if explicit" do
-        with_temp_env("VAGRANT_NO_PARALLEL" => nil) do
-          expect(Vagrant::BatchAction).to receive(:new).with(false).and_return(batch)
-          expect(batch).to receive(:run)
-
-          instance.batch(false) {}
-        end
-      end
-    end
-
-    context "with the disabling env var" do
-      it "should run with disabling parallelization" do
-        with_temp_env("VAGRANT_NO_PARALLEL" => "yes") do
-          expect(Vagrant::BatchAction).to receive(:new).with(false).and_return(batch)
-          expect(batch).to receive(:run)
-
-          instance.batch {}
-        end
-      end
-    end
-  end
-
-  describe "current working directory" do
-    it "is the cwd by default" do
-      Dir.mktmpdir("vagrant-test-env-cwd-default") do |temp_dir|
-        Dir.chdir(temp_dir) do
-          with_temp_env("VAGRANT_CWD" => nil) do
-            expect(described_class.new.cwd).to eq(Pathname.new(Dir.pwd))
-          end
-        end
-      end
-    end
-
-    it "is set to the cwd given" do
-      Dir.mktmpdir("vagrant-test-env-set-cwd") do |directory|
-        instance = described_class.new(cwd: directory)
-        expect(instance.cwd).to eq(Pathname.new(directory))
-      end
-    end
-
-    it "is set to the environmental variable VAGRANT_CWD" do
-      Dir.mktmpdir("vagrant-test-env-set-vagrant-cwd") do |directory|
-        instance = with_temp_env("VAGRANT_CWD" => directory) do
-          described_class.new
-        end
-
-        expect(instance.cwd).to eq(Pathname.new(directory))
-      end
-    end
-
-    it "raises an exception if the CWD doesn't exist" do
-      expect { described_class.new(cwd: "doesntexist") }.
-        to raise_error(Vagrant::Errors::EnvironmentNonExistentCWD)
-    end
-  end
-
-  describe "default provider" do
-    let(:plugin_providers) { {} }
-
-    before do
-      m = Vagrant.plugin("2").manager
-      allow(m).to receive(:providers).and_return(plugin_providers)
-    end
-
-    it "is the highest matching usable provider" do
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:bar)
-      end
-    end
-
-    it "is the highest matching usable provider that is defaultable" do
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [
-        provider_usable_class(true), { defaultable: false, priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:foo)
-      end
-    end
-
-    it "is the highest matching usable provider that isn't excluded" do
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider(exclude: [:bar, :foo])).to eq(:boom)
-      end
-    end
-
-    it "is the default provider set if usable" do
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "baz",
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:baz)
-      end
-    end
-
-    it "is the default provider set even if unusable" do
-      plugin_providers[:baz] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "baz",
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:baz)
-      end
-    end
-
-    it "is the usable despite default if not forced" do
-      plugin_providers[:baz] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "baz",
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider(force_default: false)).to eq(:bar)
-      end
-    end
-
-    it "prefers the default even if not forced" do
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "baz",
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider(force_default: false)).to eq(:baz)
-      end
-    end
-
-    it "uses the first usable provider that isn't the default if excluded" do
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 8 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "baz",
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider(
-          exclude: [:baz], force_default: false)).to eq(:bar)
-      end
-    end
-
-    it "raise an error if nothing else is usable" do
-      plugin_providers[:foo] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:baz] = [provider_usable_class(false), { priority: 5 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect { subject.default_provider }.to raise_error(
-          Vagrant::Errors::NoDefaultProvider)
-      end
-    end
-
-    it "is the provider in the Vagrantfile that is preferred and usable" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.provider "bar"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => 'baz,bar') do
-        expect(subject.default_provider).to eq(:bar)
-      end
-    end
-
-    it "is the provider in the Vagrantfile that is usable" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.provider "bar"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:foo)
-      end
-    end
-
-    it "is the provider in the Vagrantfile that is usable even if only one specified (1)" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:foo)
-      end
-    end
-
-    it "is the provider in the Vagrantfile that is usable even if only one specified (2)" do
-      subject.vagrantfile.config.vm.provider "bar"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 5 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:bar)
-      end
-    end
-
-    it "is the preferred usable provider outside the Vagrantfile" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => 'boom,baz') do
-        expect(subject.default_provider).to eq(:boom)
-      end
-    end
-
-    it "is the highest usable provider outside the Vagrantfile" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(false), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider).to eq(:bar)
-      end
-    end
-
-    it "is the provider in the Vagrantfile that is usable for a machine" do
-      subject.vagrantfile.config.vm.provider "foo"
-      subject.vagrantfile.config.vm.define "sub" do |v|
-        v.vm.provider "bar"
-      end
-      subject.vagrantfile.config.vm.finalize!
-
-      plugin_providers[:foo] = [provider_usable_class(true), { priority: 5 }]
-      plugin_providers[:bar] = [provider_usable_class(true), { priority: 7 }]
-      plugin_providers[:baz] = [provider_usable_class(true), { priority: 2 }]
-      plugin_providers[:boom] = [provider_usable_class(true), { priority: 3 }]
-
-      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil,
-                    "VAGRANT_PREFERRED_PROVIDERS" => nil) do
-        expect(subject.default_provider(machine: :sub)).to eq(:bar)
-      end
-    end
-  end
-
-  describe "local data path" do
-    it "is set to the proper default" do
-      default = instance.root_path.join(described_class::DEFAULT_LOCAL_DATA)
-      expect(instance.local_data_path).to eq(default)
-    end
-
-    it "is expanded relative to the cwd" do
-      Dir.mktmpdir("vagrant-test-env-relative-cwd") do |temp_dir|
-        Dir.chdir(temp_dir) do
-          instance = described_class.new(local_data_path: "foo")
-          expect(instance.local_data_path).to eq(instance.cwd.join("foo"))
-          expect(File.exist?(instance.local_data_path)).to be(false)
-        end
-      end
-    end
-
-    it "is set to the given value" do
-      Dir.mktmpdir("vagrant-test-env-set-given") do |dir|
-        instance = described_class.new(local_data_path: dir)
-        expect(instance.local_data_path.to_s).to eq(dir)
-      end
-    end
-
-    context "with environmental variable VAGRANT_DOTFILE_PATH set to the empty string" do
-      it "is set to the default, from the work directory" do
-        with_temp_env("VAGRANT_DOTFILE_PATH" => "") do
-          instance = env.create_vagrant_env
-          expect(instance.cwd).to eq(env.workdir)
-          expect(instance.local_data_path.to_s).to eq(File.join(env.workdir, ".vagrant"))
-        end
-      end
-
-      it "is set to the default, from a sub-directory of the work directory" do
-        Dir.mktmpdir("sub-directory", env.workdir) do |temp_dir|
-          with_temp_env("VAGRANT_DOTFILE_PATH" => "") do
-            instance = env.create_vagrant_env(cwd: temp_dir)
-            expect(instance.cwd.to_s).to eq(temp_dir)
-            expect(instance.local_data_path.to_s).to eq(File.join(env.workdir, ".vagrant"))
-          end
-        end
-      end
-    end
-
-    context "with environmental variable VAGRANT_DOTFILE_PATH set to an absolute path" do
-      it "is set to VAGRANT_DOTFILE_PATH from the work directory" do
-        Dir.mktmpdir("sub-directory", env.workdir) do |temp_dir|
-          dotfile_path = File.join(temp_dir, ".vagrant-custom")
-
-          with_temp_env("VAGRANT_DOTFILE_PATH" => dotfile_path) do
-            instance = env.create_vagrant_env
-            expect(instance.cwd).to eq(env.workdir)
-            expect(instance.local_data_path.to_s).to eq(dotfile_path)
-          end
-        end
-      end
-
-      it "is set to VAGRANT_DOTFILE_PATH from a sub-directory of the work directory" do
-        Dir.mktmpdir("sub-directory", env.workdir) do |temp_dir|
-          dotfile_path = File.join(temp_dir, ".vagrant-custom")
-
-          with_temp_env("VAGRANT_DOTFILE_PATH" => dotfile_path) do
-            instance = env.create_vagrant_env(cwd: temp_dir)
-            expect(instance.cwd.to_s).to eq(temp_dir)
-            expect(instance.local_data_path.to_s).to eq(dotfile_path)
-          end
-        end
-      end
-    end
-
-    context "with environmental variable VAGRANT_DOTFILE_PATH set to a relative path" do
-      it "is set relative to the the work directory, from the work directory" do
-        Dir.mktmpdir("sub-directory", env.workdir) do |temp_dir|
-          with_temp_env("VAGRANT_DOTFILE_PATH" => ".vagrant-custom") do
-            instance = env.create_vagrant_env
-            expect(instance.cwd).to eq(env.workdir)
-            expect(instance.local_data_path.to_s).to eq(File.join(env.workdir, ".vagrant-custom"))
-          end
-        end
-      end
-
-      it "is set relative to the the work directory, from a sub-directory of the work directory" do
-        Dir.mktmpdir("sub-directory", env.workdir) do |temp_dir|
-          with_temp_env("VAGRANT_DOTFILE_PATH" => ".vagrant-custom") do
-            instance = env.create_vagrant_env(cwd: temp_dir)
-            expect(instance.cwd.to_s).to eq(temp_dir)
-            expect(instance.local_data_path.to_s).to eq(File.join(env.workdir, ".vagrant-custom"))
-          end
-        end
-      end
-
-      it "is set to the empty string when there is no valid work directory" do
-        Dir.mktmpdir("out-of-tree-directory") do |temp_dir|
-          with_temp_env("VAGRANT_DOTFILE_PATH" => ".vagrant-custom") do
-            instance = env.create_vagrant_env(cwd: temp_dir)
-            expect(instance.cwd.to_s).to eq(temp_dir)
-            expect(instance.local_data_path.to_s).to eq("")
-          end
-        end
-      end
-    end
-
-    context "with environmental variable VAGRANT_DOTFILE_PATH set with tilde" do
-      it "is set relative to the user's home directory" do
-        with_temp_env("VAGRANT_DOTFILE_PATH" => "~/.vagrant") do
-          instance = env.create_vagrant_env
-          expect(instance.cwd).to eq(env.workdir)
-          expect(instance.local_data_path.to_s).to eq(File.join(Dir.home, ".vagrant"))
-        end
-      end
-    end
-
-    describe "upgrading V1 dotfiles" do
-      let(:v1_dotfile_tempfile) do
-        Tempfile.new("vagrant-upgrade-dotfile").tap do |f|
-          f.close
-        end
-      end
-
-      let(:v1_dotfile)          { Pathname.new(v1_dotfile_tempfile.path) }
-      let(:local_data_path)     { v1_dotfile_tempfile.path }
-      let(:instance) { described_class.new(local_data_path: local_data_path) }
-
-      after do
-        FileUtils.rm_rf(local_data_path)
-      end
-
-      it "should be fine if dotfile is empty" do
-        v1_dotfile.open("w+") do |f|
-          f.write("")
-        end
-
-        expect { instance }.to_not raise_error
-        expect(Pathname.new(local_data_path)).to_not be_exist
-      end
-
-      it "should upgrade all active VMs" do
-        active_vms = {
-          "foo" => "foo_id",
-          "bar" => "bar_id"
-        }
-
-        v1_dotfile.open("w+") do |f|
-          f.write(JSON.dump({
-            "active" => active_vms
-          }))
-        end
-
-        expect { instance }.to_not raise_error
-
-        local_data_pathname = Pathname.new(local_data_path)
-        foo_id_file = local_data_pathname.join("machines/foo/virtualbox/id")
-        expect(foo_id_file).to be_file
-        expect(foo_id_file.read).to eq("foo_id")
-
-        bar_id_file = local_data_pathname.join("machines/bar/virtualbox/id")
-        expect(bar_id_file).to be_file
-        expect(bar_id_file.read).to eq("bar_id")
-      end
-
-      it "should raise an error if invalid JSON" do
-        v1_dotfile.open("w+") do |f|
-          f.write("bad")
-        end
-
-        expect { instance }.
-          to raise_error(Vagrant::Errors::DotfileUpgradeJSONError)
-      end
-    end
-  end
-
-  describe "copying the private SSH key" do
-    it "copies the SSH key into the home directory" do
-      env = isolated_environment
-      instance = described_class.new(home_path: env.homedir)
-
-      pk = env.homedir.join("insecure_private_key")
-      expect(pk).to be_exist
-
-      if !Vagrant::Util::Platform.windows?
-        expect(Vagrant::Util::FileMode.from_octal(pk.stat.mode)).to eq("600")
-      end
-    end
-  end
-
-  it "has a box collection pointed to the proper directory" do
-    collection = instance.boxes
-    expect(collection).to be_kind_of(Vagrant::BoxCollection)
-    expect(collection.directory).to eq(instance.boxes_path)
-
-    # Reach into some internal state here but not sure how else
-    # to test this at the moment.
-    expect(collection.instance_variable_get(:@hook)).
-      to eq(instance.method(:hook))
-  end
-
-  describe "action runner" do
-    it "has an action runner" do
-      expect(instance.action_runner).to be_kind_of(Vagrant::Action::Runner)
-    end
-
-    it "has a `ui` in the globals" do
-      result = nil
-      callable = lambda { |env| result = env[:ui] }
-
-      instance.action_runner.run(callable)
-      expect(result).to eql(instance.ui)
-    end
-  end
-
-  describe "#pushes" do
-    it "returns the pushes from the Vagrantfile config" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF.gsub(/^ {10}/, ''))
-          Vagrant.configure("2") do |config|
-            config.push.define "noop"
-          end
-        VF
-      end
-
-      env = environment.create_vagrant_env
-      expect(env.pushes).to eq([:noop])
-    end
-  end
-
-  describe "#push" do
-    let(:push_class) do
-      Class.new(Vagrant.plugin("2", :push)) do
-        def self.pushed?
-          !!class_variable_get(:@@pushed)
-        end
-
-        def push
-          self.class.class_variable_set(:@@pushed, true)
-        end
-      end
-    end
-
-    it "raises an exception when the push does not exist" do
-      expect { instance.push("lolwatbacon") }
-        .to raise_error(Vagrant::Errors::PushStrategyNotDefined)
-    end
-
-    it "raises an exception if the strategy does not exist" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF.gsub(/^ {10}/, ''))
-          Vagrant.configure("2") do |config|
-            config.push.define "lolwatbacon"
-          end
-        VF
-      end
-
-      env = environment.create_vagrant_env
-      expect { env.push("lolwatbacon") }
-        .to raise_error(Vagrant::Errors::PushStrategyNotLoaded)
-    end
-
-    it "executes the push action" do
-      register_plugin("2") do |plugin|
-        plugin.name "foo"
-
-        plugin.push(:foo) do
-          push_class
-        end
-      end
-
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF.gsub(/^ {10}/, ''))
-          Vagrant.configure("2") do |config|
-            config.push.define "foo"
-          end
-        VF
-      end
-
-      env = environment.create_vagrant_env
-      env.push("foo")
-      expect(push_class.pushed?).to be(true)
-    end
-  end
-
-  describe "#hook" do
-    it "should call the action runner with the proper hook" do
-      hook_name = :foo
-
-      expect(instance.action_runner).to receive(:run).with(any_args) { |callable, env|
-        expect(env[:action_name]).to eq(hook_name)
-      }
-
-      instance.hook(hook_name)
-    end
-
-    it "should return the result of the action runner run" do
-      expect(instance.action_runner).to receive(:run).and_return(:foo)
-
-      expect(instance.hook(:bar)).to eq(:foo)
-    end
-
-    it "should allow passing in a custom action runner" do
-      expect(instance.action_runner).not_to receive(:run)
-      other_runner = double("runner")
-      expect(other_runner).to receive(:run).and_return(:foo)
-
-      expect(instance.hook(:bar, runner: other_runner)).to eq(:foo)
-    end
-
-    it "should allow passing in custom data" do
-      expect(instance.action_runner).to receive(:run).with(any_args) { |callable, env|
-        expect(env[:foo]).to eq(:bar)
-      }
-
-      instance.hook(:foo, foo: :bar)
-    end
-
-    it "should allow passing a custom callable" do
-      expect(instance.action_runner).to receive(:run).with(any_args) { |callable, env|
-        expect(callable).to eq(:what)
-      }
-
-      instance.hook(:foo, callable: :what)
-    end
-  end
-
-  describe "primary machine name" do
-    it "should be the only machine if not a multi-machine environment" do
-      expect(instance.primary_machine_name).to eq(instance.machine_names.first)
-    end
-
-    it "should be the machine marked as the primary" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.define :foo
-  config.vm.define :bar, primary: true
-end
-VF
-
-        env.box3("base", "1.0", :virtualbox)
-      end
-
-      env = environment.create_vagrant_env
-      expect(env.primary_machine_name).to eq(:bar)
-    end
-
-    it "should be nil if no primary is specified in a multi-machine environment" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.box = "base"
-  config.vm.define :foo
-  config.vm.define :bar
-end
-VF
-
-        env.box3("base", "1.0", :virtualbox)
-      end
-
-      env = environment.create_vagrant_env
-      expect(env.primary_machine_name).to be_nil
-    end
-  end
-
-  describe "loading configuration" do
-    it "should load global configuration" do
-      environment = isolated_environment do |env|
-        env.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 200
-end
-VF
-      end
-
-      env = environment.create_vagrant_env
-      expect(env.vagrantfile.config.ssh.port).to eq(200)
-    end
-
-    it "should load from a custom Vagrantfile" do
-      environment = isolated_environment do |env|
-        env.file("non_standard_name", <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 200
-end
-VF
-      end
-
-      env = environment.create_vagrant_env(vagrantfile_name: "non_standard_name")
-      expect(env.vagrantfile.config.ssh.port).to eq(200)
-    end
-
-    it "should load from a custom Vagrantfile specified by env var" do
-      environment = isolated_environment do |env|
-        env.file("some_other_name", <<-VF)
-Vagrant.configure("2") do |config|
-  config.ssh.port = 400
-end
-VF
-      end
-
-      env = with_temp_env("VAGRANT_VAGRANTFILE" => "some_other_name") do
-        environment.create_vagrant_env
-      end
-
-      expect(env.vagrantfile.config.ssh.port).to eq(400)
-    end
-  end
-
-  describe "ui" do
-    it "should be a silent UI by default" do
-      expect(described_class.new.ui).to be_kind_of(Vagrant::UI::Silent)
-    end
-
-    it "should be a UI given in the constructor" do
-      # Create a custom UI for our test
-      class CustomUI < Vagrant::UI::Interface; end
-
-      instance = described_class.new(ui_class: CustomUI)
-      expect(instance.ui).to be_kind_of(CustomUI)
-    end
-  end
-
-  describe "#unload" do
-    it "should run the unload hook" do
-      expect(instance).to receive(:hook).with(:environment_unload).once
-      instance.unload
-    end
-  end
-
-  describe "getting machine names" do
-    it "should return the default machine if no multi-VM is used" do
-      # Create the config
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-end
-VF
-      end
-
-      env = isolated_env.create_vagrant_env
-      expect(env.machine_names).to eq([:default])
-    end
-
-    it "should return the machine names in order" do
-      # Create the config
-      isolated_env = isolated_environment do |e|
-        e.vagrantfile(<<-VF)
-Vagrant.configure("2") do |config|
-  config.vm.define "foo"
-  config.vm.define "bar"
-end
-VF
-      end
-
-      env = isolated_env.create_vagrant_env
-      expect(env.machine_names).to eq([:foo, :bar])
-    end
-  end
-end