tnargav 1.3.5 → 1.3.6

data/test/unit/vagrant/config/v2/loader_test.rb

@@ -0,0 +1,151 @@
+require "ostruct"
+
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Config::V2::Loader do
+  include_context "unit"
+
+  before(:each) do
+    # Force the V2 loader to believe that we are in V2
+    stub_const("Vagrant::Config::CURRENT_VERSION", "2")
+  end
+
+  describe "empty" do
+    it "returns an empty configuration object" do
+      result = described_class.init
+      result.should be_kind_of(Vagrant::Config::V2::Root)
+    end
+  end
+
+  describe "finalizing" do
+    it "should call `#finalize` on the configuration object" do
+      # Register a plugin for our test
+      register_plugin("2") do |plugin|
+        plugin.config "foo" do
+          Class.new do
+            attr_accessor :bar
+
+            def finalize!
+              @bar = "finalized"
+            end
+          end
+        end
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      config.foo.bar.should == "value"
+
+      # Finalize it
+      described_class.finalize(config)
+      config.foo.bar.should == "finalized"
+    end
+  end
+
+  describe "loading" do
+    it "should configure with all plugin config keys loaded" do
+      # Register a plugin for our test
+      register_plugin("2") do |plugin|
+        plugin.config("foo") { OpenStruct }
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      config.foo.bar.should == "value"
+    end
+  end
+
+  describe "merging" do
+    it "should merge available configuration keys" do
+      old = Vagrant::Config::V2::Root.new({ :foo => Object })
+      new = Vagrant::Config::V2::Root.new({ :bar => Object })
+      result = described_class.merge(old, new)
+      result.foo.should be_kind_of(Object)
+      result.bar.should be_kind_of(Object)
+    end
+
+    it "should merge instantiated objects" do
+      config_class = Class.new do
+        attr_accessor :value
+      end
+
+      old = Vagrant::Config::V2::Root.new({ :foo => config_class })
+      old.foo.value = "old"
+
+      new = Vagrant::Config::V2::Root.new({ :bar => config_class })
+      new.bar.value = "new"
+
+      result = described_class.merge(old, new)
+      result.foo.value.should == "old"
+      result.bar.value.should == "new"
+    end
+
+    it "should merge conflicting classes by calling `merge`" do
+      config_class = Class.new do
+        attr_accessor :value
+
+        def merge(new)
+          result       = self.class.new
+          result.value = @value + new.value
+          result
+        end
+      end
+
+      old = Vagrant::Config::V2::Root.new({ :foo => config_class })
+      old.foo.value = 10
+
+      new = Vagrant::Config::V2::Root.new({ :foo => config_class })
+      new.foo.value = 15
+
+      result = described_class.merge(old, new)
+      result.foo.value.should == 25
+    end
+  end
+
+  describe "upgrading" do
+    it "should continue fine if the key doesn't implement upgrade" do
+      # Make an old V1 root object
+      old = Vagrant::Config::V1::Root.new({ :foo => Class.new })
+
+      # It should work fine
+      expect { result = described_class.upgrade(old) }.to_not raise_error
+    end
+
+    it "should upgrade the config if it implements the upgrade method" do
+      # Create the old V1 class that will be upgraded
+      config_class = Class.new do
+        attr_accessor :value
+
+        def upgrade(new)
+          new.foo.value = value * 2
+
+          [["foo"], ["bar"]]
+        end
+      end
+
+      # Create the new V2 plugin it is writing to
+      register_plugin("2") do |p|
+        p.config("foo") { OpenStruct }
+      end
+
+      # Test it out!
+      old = Vagrant::Config::V1::Root.new({ :foo => config_class })
+      old.foo.value = 5
+
+      data = described_class.upgrade(old)
+      data[0].foo.value.should == 10
+      data[1].should == ["foo"]
+      data[2].should == ["bar"]
+    end
+  end
+end

data/test/unit/vagrant/config/v2/root_test.rb

@@ -0,0 +1,115 @@
+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
+    foo.should be_kind_of(foo_class)
+    instance.foo.should 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
+    instance.__internal_state["missing_key_calls"].include?("foo").should 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" })
+    instance.foo.should == "bar"
+  end
+
+  it "should return internal state" do
+    map      = { "foo" => Object, "bar" => Object }
+    instance = described_class.new(map)
+    instance.__internal_state.should == {
+      "config_map"        => map,
+      "keys"              => {},
+      "missing_key_calls" => Set.new
+    }
+  end
+
+  describe "finalization" do
+    it "should finalize un-used keys" do
+      foo_class = Class.new do
+        attr_accessor :foo
+
+        def finalize!
+          @foo = "SET"
+        end
+      end
+
+      map = { :foo => foo_class }
+      instance = described_class.new(map)
+      instance.finalize!
+
+      instance.foo.foo.should == "SET"
+    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
+      instance.validate({}).should == {}
+    end
+
+    it "should return errors if invalid" do
+      errors = { "foo" => ["errors!"] }
+      env    = { "errors" => errors }
+      foo    = instance.foo
+      def foo.validate(env)
+        env["errors"]
+      end
+
+      instance.validate(env).should == 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"]
+      }
+
+      instance.validate(env).should == 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
+
+      instance.validate(env).should == {}
+    end
+  end
+end

data/test/unit/vagrant/config/v2/util_test.rb

@@ -0,0 +1,21 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require "vagrant/config/v2/util"
+
+describe Vagrant::Config::V2::Util do
+  describe "merging errors" do
+    it "should merge matching keys and leave the rest alone" do
+      first  = { "one" => ["foo"], "two" => ["two"] }
+      second = { "one" => ["bar"], "three" => ["three"] }
+
+      expected = {
+        "one" => ["foo", "bar"],
+        "two" => ["two"],
+        "three" => ["three"]
+      }
+
+      result = described_class.merge_errors(first, second)
+      result.should == expected
+    end
+  end
+end

data/test/unit/vagrant/config_test.rb

@@ -0,0 +1,66 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Config do
+  it "should not execute the proc on configuration" do
+    described_class.run do
+      raise Exception, "Failure."
+    end
+  end
+
+  it "should capture calls to `Vagrant.configure`" do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      Vagrant.configure("1") do
+        receiver.one
+      end
+
+      Vagrant.configure("2") do
+        receiver.two
+      end
+    end
+
+    procs.should be_kind_of(Array)
+    procs.length.should == 2
+    procs[0][0].should == "1"
+    procs[1][0].should == "2"
+
+    # Verify the proper procs were captured
+    receiver.should_receive(:one).once.ordered
+    receiver.should_receive(:two).once.ordered
+    procs[0][1].call
+    procs[1][1].call
+  end
+
+  it "should capture configuration procs" do
+    receiver = double()
+
+    procs = described_class.capture_configures do
+      described_class.run do
+        receiver.hello!
+      end
+    end
+
+    # Verify the structure of the result
+    procs.should be_kind_of(Array)
+    procs.length.should == 1
+
+    # Verify that the proper proc was captured
+    receiver.should_receive(:hello!).once
+    procs[0][0].should == "1"
+    procs[0][1].call
+  end
+
+  it "should capture the proper version" do
+    procs = described_class.capture_configures do
+      described_class.run("1") {}
+      described_class.run("2") {}
+    end
+
+    # Verify the structure of the result
+    procs.should be_kind_of(Array)
+    procs.length.should == 2
+    procs[0][0].should == "1"
+    procs[1][0].should == "2"
+  end
+end

data/test/unit/vagrant/environment_test.rb

@@ -0,0 +1,746 @@
+require File.expand_path("../../base", __FILE__)
+require "json"
+require "pathname"
+require "tempfile"
+require "tmpdir"
+
+require "vagrant/util/file_mode"
+
+describe Vagrant::Environment do
+  include_context "unit"
+
+  let(:env) do
+    isolated_environment.tap do |e|
+      e.box2("base", :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 "active machines" do
+    it "should be empty if the machines folder doesn't exist" do
+      folder = instance.local_data_path.join("machines")
+      folder.should_not be_exist
+
+      instance.active_machines.should 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
+
+      instance.active_machines.should == [[:foo, :virtualbox]]
+    end
+  end
+
+  describe "batching" do
+    let(:batch) do
+      double("batch") do |b|
+        b.stub(: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
+          Vagrant::BatchAction.should_receive(:new).with(true).and_return(batch)
+          batch.should_receive(:run)
+
+          instance.batch {}
+        end
+      end
+
+      it "should run with disabling parallelization if explicit" do
+        with_temp_env("VAGRANT_NO_PARALLEL" => nil) do
+          Vagrant::BatchAction.should_receive(:new).with(false).and_return(batch)
+          batch.should_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
+          Vagrant::BatchAction.should_receive(:new).with(false).and_return(batch)
+          batch.should_receive(:run)
+
+          instance.batch {}
+        end
+      end
+    end
+  end
+
+  describe "current working directory" do
+    it "is the cwd by default" do
+      Dir.mktmpdir do |temp_dir|
+        Dir.chdir(temp_dir) do
+          with_temp_env("VAGRANT_CWD" => nil) do
+            described_class.new.cwd.should == Pathname.new(Dir.pwd)
+          end
+        end
+      end
+    end
+
+    it "is set to the cwd given" do
+      Dir.mktmpdir do |directory|
+        instance = described_class.new(:cwd => directory)
+        instance.cwd.should == Pathname.new(directory)
+      end
+    end
+
+    it "is set to the environmental variable VAGRANT_CWD" do
+      Dir.mktmpdir do |directory|
+        instance = with_temp_env("VAGRANT_CWD" => directory) do
+          described_class.new
+        end
+
+        instance.cwd.should == 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
+    it "is virtualbox without any environmental variable" do
+      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => nil) do
+        subject.default_provider.should == :virtualbox
+      end
+    end
+
+    it "is whatever the environmental variable is if set" do
+      with_temp_env("VAGRANT_DEFAULT_PROVIDER" => "foo") do
+        subject.default_provider.should == :foo
+      end
+    end
+  end
+
+  describe "home path" do
+    it "is set to the home path given" do
+      Dir.mktmpdir do |dir|
+        instance = described_class.new(:home_path => dir)
+        instance.home_path.should == Pathname.new(dir)
+      end
+    end
+
+    it "is set to the environmental variable VAGRANT_HOME" do
+      Dir.mktmpdir do |dir|
+        instance = with_temp_env("VAGRANT_HOME" => dir) do
+          described_class.new
+        end
+
+        instance.home_path.should == Pathname.new(dir)
+      end
+    end
+
+    context "default home path" do
+      before :each do
+        Vagrant::Util::Platform.stub(:windows? => false)
+      end
+
+      it "is set to '~/.vagrant.d' by default" do
+        expected = Pathname.new(File.expand_path("~/.vagrant.d"))
+        described_class.new.home_path.should == expected
+      end
+
+      it "is set to '~/.vagrant.d' if on Windows but no USERPROFILE" do
+        Vagrant::Util::Platform.stub(:windows? => true)
+
+        expected = Pathname.new(File.expand_path("~/.vagrant.d"))
+
+        with_temp_env("USERPROFILE" => nil) do
+          described_class.new.home_path.should == expected
+        end
+      end
+
+      it "is set to '%USERPROFILE%/.vagrant.d' if on Windows and USERPROFILE is set" do
+        Vagrant::Util::Platform.stub(:windows? => true)
+
+        Dir.mktmpdir do |dir|
+          expected = Pathname.new(File.expand_path("#{dir}/.vagrant.d"))
+
+          with_temp_env("USERPROFILE" => dir) do
+            described_class.new.home_path.should == expected
+          end
+        end
+      end
+    end
+
+    it "throws an exception if inaccessible" do
+      expect {
+        described_class.new(:home_path => "/")
+      }.to raise_error(Vagrant::Errors::HomeDirectoryNotAccessible)
+    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)
+      instance.local_data_path.should == default
+    end
+
+    it "is expanded relative to the cwd" do
+      instance = described_class.new(:local_data_path => "foo")
+      instance.local_data_path.should == instance.cwd.join("foo")
+    end
+
+    it "is set to the given value" do
+      Dir.mktmpdir do |dir|
+        instance = described_class.new(:local_data_path => dir)
+        instance.local_data_path.to_s.should == dir
+      end
+    end
+
+    describe "upgrading V1 dotfiles" do
+      let(:v1_dotfile_tempfile) { Tempfile.new("vagrant") }
+      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) }
+
+      it "should be fine if dotfile is empty" do
+        v1_dotfile.open("w+") do |f|
+          f.write("")
+        end
+
+        expect { instance }.to_not raise_error
+        Pathname.new(local_data_path).should be_directory
+      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")
+        foo_id_file.should be_file
+        foo_id_file.read.should == "foo_id"
+
+        bar_id_file = local_data_pathname.join("machines/bar/virtualbox/id")
+        bar_id_file.should be_file
+        bar_id_file.read.should == "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")
+      pk.should be_exist
+      Vagrant::Util::FileMode.from_octal(pk.stat.mode).should == "600"
+    end
+  end
+
+  it "has a box collection pointed to the proper directory" do
+    collection = instance.boxes
+    collection.should be_kind_of(Vagrant::BoxCollection)
+    collection.directory.should == instance.boxes_path
+  end
+
+  describe "action runner" do
+    it "has an action runner" do
+      instance.action_runner.should 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)
+      result.should eql(instance.ui)
+    end
+  end
+
+  describe "#hook" do
+    it "should call the action runner with the proper hook" do
+      hook_name = :foo
+
+      instance.action_runner.should_receive(:run).with do |callable, env|
+        env[:action_name].should == hook_name
+      end
+
+      instance.hook(hook_name)
+    end
+
+    it "should return the result of the action runner run" do
+      instance.action_runner.should_receive(:run).and_return(:foo)
+
+      instance.hook(:bar).should == :foo
+    end
+  end
+
+  describe "primary machine name" do
+    it "should be the only machine if not a multi-machine environment" do
+      instance.primary_machine_name.should == 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.box2("base", :virtualbox)
+      end
+
+      env = environment.create_vagrant_env
+      env.primary_machine_name.should == :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.box2("base", :virtualbox)
+      end
+
+      env = environment.create_vagrant_env
+      env.primary_machine_name.should 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
+      env.config_global.ssh.port.should == 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")
+      env.config_global.ssh.port.should == 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
+
+      env.config_global.ssh.port.should == 400
+    end
+  end
+
+  describe "ui" do
+    it "should be a silent UI by default" do
+      described_class.new.ui.should 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)
+      instance.ui.should be_kind_of(CustomUI)
+    end
+  end
+
+  describe "#unload" do
+    it "should run the unload hook" do
+      instance.should_receive(:hook).with(:environment_unload).once
+      instance.unload
+    end
+  end
+
+  describe "getting a 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(Vagrant.plugin("2", :provider))
+
+      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.box2("base", :foo)
+      end
+
+      # Verify that we can get the machine
+      env = isolated_env.create_vagrant_env
+      machine = env.machine(:foo, :foo)
+      machine.should be_kind_of(Vagrant::Machine)
+      machine.name.should == :foo
+      machine.provider.should be_kind_of(foo_provider)
+      machine.provider_config.should 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.box2("base", :foo)
+      end
+
+      # Verify that we can get the machine
+      env = isolated_env.create_vagrant_env
+      machine = env.machine(:foo, :foo)
+      machine.should be_kind_of(Vagrant::Machine)
+      machine.name.should == :foo
+      machine.provider.should be_kind_of(foo_provider)
+      machine.provider_config.value.should == 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.box2("base", :foo)
+        e.box2("base", :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)
+
+      vm1_foo.should eql(env.machine(:vm1, :foo))
+      vm1_bar.should eql(env.machine(:vm1, :bar))
+      vm1_foo.should_not eql(vm1_bar)
+      vm2_foo.should 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)
+      machine.box.should 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.box2("base", :foo)
+      end
+
+      env = environment.create_vagrant_env
+      machine = env.machine(:vm1, :foo)
+      machine.config.ssh.port.should == 100
+      machine.config.vm.box.should == "base"
+    end
+
+    it "should load the box configuration for a V2 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.box2("base", :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)
+      machine.config.ssh.port.should == 100
+    end
+
+    it "should load the box configuration for a V2 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.box2("base", :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)
+      machine.config.ssh.port.should == 100
+    end
+
+    it "should load the box configuration for other formats for a V2 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.box2("base", :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)
+      machine.config.ssh.port.should == 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.box2("base", :fA, :vagrantfile => <<-VF)
+Vagrant.configure("2") do |config|
+  config.ssh.port = 100
+end
+VF
+
+        env.box2("base", :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)
+      machine.config.ssh.port.should == 100
+    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)
+      foo_vm.config.vm.box.should == "bar"
+      bar_vm.config.vm.box.should == "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.box2("base", :foo)
+      end
+
+      env = isolated_env.create_vagrant_env
+      vm1 = env.machine(:default, :foo)
+      vm2 = env.machine(:default, :foo, true)
+      vm3 = env.machine(:default, :foo)
+
+      vm1.should_not eql(vm2)
+      vm2.should 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 "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
+      env.machine_names.should == [: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
+      env.machine_names.should == [:foo, :bar]
+    end
+  end
+end