boxcar 0.10005.1

data/test/unit_legacy/vagrant/config/vm/provisioner_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class ConfigVMProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config::VMConfig::Provisioner
+    @top = Vagrant::Config::Top.new(nil)
+  end
+
+  context "initializing" do
+    should "expose the top instance that the provisioner belongs to" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.top
+    end
+
+    should "expose the shortcut used" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal :chef_solo, instance.shortcut
+    end
+
+    should "expose the provisioner class if its a valid shortcut" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "expose the provisioner class if its a valid class" do
+      instance = @klass.new(@top, Vagrant::Provisioners::ChefSolo)
+      assert_equal Vagrant::Provisioners::ChefSolo, instance.provisioner
+    end
+
+    should "have a nil provisioner class if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.provisioner
+    end
+
+    should "have a nil config instance if invalid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      assert_nil instance.config
+    end
+
+    should "set the top of the config object to the given top" do
+      instance = @klass.new(@top, :chef_solo)
+      assert_equal @top, instance.config.top
+    end
+
+    should "configure the provisioner if valid" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.cookbooks_path = "foo"
+      end
+
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+
+    should "configure the provisioner with a hash if valid" do
+      instance = @klass.new(@top, :chef_solo, :cookbooks_path => "foo")
+      assert_equal "foo", instance.config.cookbooks_path
+    end
+  end
+
+  context "validation" do
+    setup do
+      @errors = Vagrant::Config::ErrorRecorder.new
+    end
+
+    should "be invalid if provisioner is valid" do
+      instance = @klass.new(@top, :i_shall_never_exist)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if provisioner doesn't inherit from provisioners base" do
+      klass = Class.new
+      instance = @klass.new(@top, klass)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be valid with a valid provisioner" do
+      instance = @klass.new(@top, :chef_solo) do |chef|
+        chef.add_recipe "foo"
+      end
+
+      instance.validate(@errors)
+      assert @errors.errors.empty?
+    end
+
+    should "be invalid if a provisioner's config is invalid" do
+      instance = @klass.new(@top, :chef_solo)
+      instance.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+  end
+end

data/test/unit_legacy/vagrant/config/vm_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class ConfigVMTest < Test::Unit::TestCase
+  setup do
+    @username = "mitchellh"
+
+    @env = vagrant_env
+    @config = @env.config.vm
+    @env.config.ssh.username = @username
+  end
+
+  context "defining VMs" do
+    should "store the proc by name but not run it" do
+      foo = mock("proc")
+      foo.expects(:call).never
+
+      proc = Proc.new { foo.call }
+      @config.define(:name, &proc)
+      assert @config.defined_vms[:name].proc_stack.include?(proc)
+    end
+
+    should "store the options" do
+      @config.define(:name, :set => true)
+      assert @config.defined_vms[:name].options[:set]
+    end
+
+    should "retain vm definition order" do
+      @config.define(:a) {}
+      @config.define(:b) {}
+      @config.define(:c) {}
+
+      assert_equal [:a, :b, :c], @config.defined_vm_keys
+    end
+  end
+
+  context "customizing" do
+    should "include the stacked proc runner module" do
+      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
+    end
+
+    should "add the customize proc to the proc stack" do
+      proc = Proc.new {}
+      @config.customize(&proc)
+      assert @config.proc_stack.include?(proc)
+    end
+  end
+end

data/test/unit_legacy/vagrant/config_test.rb

@@ -0,0 +1,148 @@
+require "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config
+  end
+
+  context "with an instance" do
+    setup do
+      @instance = @klass.new
+    end
+
+    should "load the config files in the given order" do
+      names = %w{alpha beta gamma}
+
+      @instance.load_order = [:alpha, :beta]
+
+      names.each do |name|
+        vagrantfile(vagrant_box(name), "config.vm.box = '#{name}'")
+        @instance.set(name.to_sym, vagrant_box(name).join("Vagrantfile"))
+      end
+
+      config = @instance.load(nil)
+      assert_equal "beta", config.vm.box
+    end
+
+    should "load the config as procs" do
+      @instance.set(:proc, Proc.new { |config| config.vm.box = "proc" })
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
+
+      assert_equal "proc", config.vm.box
+    end
+
+    should "load an array of procs" do
+      @instance.set(:proc, [Proc.new { |config| config.vm.box = "proc" },
+                            Proc.new { |config| config.vm.box = "proc2" }])
+      @instance.load_order = [:proc]
+      config = @instance.load(nil)
+
+      assert_equal "proc2", config.vm.box
+    end
+
+    should "not care if a file doesn't exist" do
+      @instance.load_order = [:foo]
+      assert_nothing_raised { @instance.set(:foo, "i/dont/exist") }
+      assert_nothing_raised { @instance.load(nil) }
+    end
+
+    should "not reload a file" do
+      foo_path = vagrant_box("foo").join("Vagrantfile")
+
+      vagrantfile(vagrant_box("foo"))
+      @instance.set(:foo, foo_path)
+
+      # Nothing should be raised in this case because the file isn't reloaded
+      vagrantfile(vagrant_box("foo"), "^%&8318")
+      assert_nothing_raised { @instance.set(:foo, foo_path) }
+    end
+
+    should "raise an exception if there is a syntax error in a file" do
+      vagrantfile(vagrant_box("foo"), "^%&8318")
+
+      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
+        @instance.set(:foo, vagrant_box("foo").join("Vagrantfile"))
+      }
+    end
+  end
+
+  context "top config class" do
+    setup do
+      @configures_list = {}
+      @klass::Top.stubs(:configures_list).returns(@configures_list)
+    end
+
+    context "adding configure keys" do
+      setup do
+        @key = "top_config_foo"
+        @config_klass = mock("klass")
+      end
+
+      should "add key and klass to configures list" do
+        @klass::Top.configures(@key, @config_klass)
+        assert_equal @config_klass, @configures_list[@key]
+      end
+    end
+
+    context "configuration keys on instance" do
+      setup do
+        @configures_list.clear
+      end
+
+      should "initialize each configurer and set it to its key" do
+        env = mock('env')
+
+        5.times do |i|
+          key = "key#{i}"
+          klass = mock("klass#{i}")
+          instance = mock("instance#{i}")
+          instance.expects(:top=).with() do |top|
+            assert top.is_a?(@klass::Top)
+            true
+          end
+          klass.expects(:new).returns(instance)
+          @configures_list[key] = klass
+        end
+
+        @klass::Top.new(env)
+      end
+
+      should "allow reading via methods" do
+        key = "my_foo_bar_key"
+        klass = mock("klass")
+        instance = mock("instance")
+        instance.stubs(:top=)
+        klass.expects(:new).returns(instance)
+        @klass::Top.configures(key, klass)
+
+        config = @klass::Top.new
+        assert_equal instance, config.send(key)
+      end
+    end
+
+    context "validation" do
+      should "do nothing if no errors are added" do
+        valid_class = Class.new(@klass::Base)
+        @klass::Top.configures(:subconfig, valid_class)
+        instance = @klass::Top.new
+        assert_nothing_raised { instance.validate! }
+      end
+
+      should "raise an exception if there are errors" do
+        invalid_class = Class.new(@klass::Base) do
+          def validate(errors)
+            errors.add("vagrant.test.errors.test_key")
+          end
+        end
+
+        @klass::Top.configures(:subconfig, invalid_class)
+        instance = @klass::Top.new
+
+        assert_raises(Vagrant::Errors::ConfigValidationFailed) {
+          instance.validate!
+        }
+      end
+    end
+  end
+end

data/test/unit_legacy/vagrant/downloaders/http_test.rb

@@ -0,0 +1,93 @@
+require "test_helper"
+
+class HttpDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = vagrant_mock_downloader(Vagrant::Downloaders::HTTP)
+    @downloader.stubs(:report_progress)
+    @downloader.stubs(:complete_progress)
+    @uri = "http://google.com/"
+    @headers = nil
+  end
+
+  context "downloading" do
+    setup do
+      ENV["http_proxy"] = nil
+
+      @parsed_uri = URI.parse(@uri)
+      @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+      Net::HTTP.stubs(:new).returns(@http)
+      @http.stubs(:start)
+    end
+
+    should "create a proper net/http object" do
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port, nil, nil, nil, nil).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "create a proper net/http object with a proxy" do
+      ENV["http_proxy"] = "http://user:foo@google.com"
+      @proxy = URI.parse(ENV["http_proxy"])
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port, @proxy.host, @proxy.port, @proxy.user, @proxy.password).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "create a proper net/http object without a proxy if no_proxy defined" do
+      @uri = "http://somewhere.direct.com/some_file"
+      @parsed_uri = URI.parse(@uri)
+      ENV["http_proxy"] = "http://user:foo@google.com"
+      ENV["no_proxy"] = "direct.com"
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port, nil, nil, nil, nil).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "enable SSL if scheme is https" do
+      @uri = "https://google.com/"
+      @http.expects(:use_ssl=).with(true).once
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "read the body of the response and place each segment into the file" do
+      h = mock("http")
+      response = mock("response")
+      response.stubs(:content_length)
+      response.stubs(:is_a?).with(anything).returns(false)
+      response.stubs(:is_a?).with(Net::HTTPOK).returns(true)
+      segment = mock("segment")
+      segment.stubs(:length).returns(7)
+
+      @http.stubs(:start).yields(h)
+      h.expects(:request_get).with(@parsed_uri.request_uri, @headers).once.yields(response)
+      response.expects(:read_body).once.yields(segment)
+      @tempfile.expects(:write).with(segment).once
+
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "error environment if invalid URL given" do
+      Net::HTTP.expects(:new).raises(SocketError.new)
+
+      assert_raises(Vagrant::Errors::DownloaderHTTPSocketError) {
+        @downloader.download!(@uri, @tempfile)
+      }
+    end
+  end
+
+  context "matching the uri" do
+    should "use extract to verify that the string is in fact a uri" do
+      URI.expects(:extract).returns(['foo'])
+      assert Vagrant::Downloaders::HTTP.match?('foo')
+    end
+
+    should "return false if there are no extract results" do
+      URI.expects(:extract).returns([])
+      assert !Vagrant::Downloaders::HTTP.match?('foo')
+    end
+  end
+
+  context "reporting progress" do
+    # TODO: Testing for this, probably
+  end
+end

data/test/unit_legacy/vagrant/environment_test.rb

@@ -0,0 +1,539 @@
+require "test_helper"
+require "pathname"
+require "tempfile"
+
+class EnvironmentTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Environment
+
+    clean_paths
+  end
+
+  context "class method check virtualbox version" do
+    setup do
+      VirtualBox.stubs(:version).returns("4.1.0")
+    end
+
+    should "not error and exit if everything is good" do
+      VirtualBox.expects(:version).returns("4.1.0")
+      assert_nothing_raised { @klass.check_virtualbox! }
+    end
+
+    should "error and exit if VirtualBox is not installed or detected" do
+      VirtualBox.expects(:version).returns(nil)
+      assert_raises(Vagrant::Errors::VirtualBoxNotDetected) { @klass.check_virtualbox! }
+    end
+
+    should "error and exit if VirtualBox is lower than version 4.0" do
+      version = "3.2.12r1041"
+      VirtualBox.expects(:version).returns(version)
+      assert_raises(Vagrant::Errors::VirtualBoxInvalidVersion) { @klass.check_virtualbox! }
+    end
+  end
+
+  context "initialization" do
+    should "set the cwd if given" do
+      cwd = "foobarbaz"
+      env = @klass.new(:cwd => cwd)
+      assert_equal Pathname.new(cwd), env.cwd
+    end
+
+    should "default to pwd if cwd is nil" do
+      env = @klass.new
+      assert_equal Pathname.new(Dir.pwd), env.cwd
+    end
+  end
+
+  context "paths" do
+    setup do
+      @env = vagrant_env
+    end
+
+    context "dotfile path" do
+      should "build up the dotfile out of the root path and the dotfile name" do
+        assert_equal @env.root_path.join(@env.config.vagrant.dotfile_name), @env.dotfile_path
+      end
+    end
+
+    context "home path" do
+      setup do
+        @env = @klass.new
+
+        # Make a fake home directory for helping with tests
+        @home_path = tmp_path.join("home")
+        ENV["HOME"] = @home_path.to_s
+        FileUtils.rm_rf(@home_path)
+        FileUtils.mkdir_p(@home_path)
+      end
+
+      should "return the home path if it loaded" do
+        ENV["VAGRANT_HOME"] = nil
+
+        expected = Pathname.new(File.expand_path(@klass::DEFAULT_HOME))
+        assert_equal expected, @env.home_path
+      end
+
+      should "return the home path set by the environmental variable" do
+        ENV["VAGRANT_HOME"] = "foo"
+
+        expected = Pathname.new(File.expand_path(ENV["VAGRANT_HOME"]))
+        assert_equal expected, @env.home_path
+      end
+    end
+
+    context "temp path" do
+      should "return the home path joined with 'tmp'" do
+        assert_equal @env.home_path.join("tmp"), @env.tmp_path
+      end
+    end
+
+    context "boxes path" do
+      should "return the home path joined with 'tmp'" do
+        assert_equal @env.home_path.join("boxes"), @env.boxes_path
+      end
+    end
+  end
+
+  context "resource" do
+    setup do
+      @env = vagrant_env
+    end
+
+    should "return 'vagrant' as a default" do
+      assert_equal 'vagrant', @env.resource
+    end
+
+    should "return the VM name if it is specified" do
+      @env.stubs(:vm).returns(mock("vm", :name => "foo"))
+      assert_equal "foo", @env.resource
+    end
+  end
+
+  context "primary VM helper" do
+    should "return the first VM if not multivm" do
+      env = vagrant_env
+      assert_equal env.vms[@klass::DEFAULT_VM], env.primary_vm
+    end
+
+    should "call and return the primary VM from the parent if has one" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define(:web, :primary => true) do; end
+        config.vm.define :db do; end
+      vf
+
+      assert_equal :web, env.primary_vm.name
+    end
+
+    should "return nil if no VM is marked as primary" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+        config.vm.define :utility
+      vf
+
+      assert env.primary_vm.nil?
+    end
+  end
+
+  context "multivm? helper" do
+    should "return true if VM length greater than 1" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      assert env.multivm?
+    end
+
+    should "return true if VM length is 1 and a sub-VM is defined" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+      vf
+
+      assert env.multivm?
+    end
+
+    should "return false if only default VM exists" do
+      assert !vagrant_env.multivm?
+    end
+  end
+
+  context "local data" do
+    should "lazy load the data store only once" do
+      result = { :foo => :bar }
+      Vagrant::DataStore.expects(:new).returns(result).once
+      env = vagrant_env
+      assert_equal result, env.local_data
+      assert_equal result, env.local_data
+      assert_equal result, env.local_data
+    end
+
+    should "return the parent's local data if a parent exists" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      env.local_data[:foo] = :bar
+
+      Vagrant::DataStore.expects(:new).never
+      assert_equal :bar, env.vms[:web].env.local_data[:foo]
+    end
+  end
+
+  context "accessing host" do
+    should "load the host once" do
+      env = @klass.new(:cwd => vagrantfile)
+      result = mock("result")
+      Vagrant::Hosts::Base.expects(:load).with(env, env.config.vagrant.host).once.returns(result)
+      assert_equal result, env.host
+      assert_equal result, env.host
+      assert_equal result, env.host
+    end
+  end
+
+  context "accessing actions" do
+    should "initialize the Action object with the given environment" do
+      env = @klass.new(:cwd => vagrant_app)
+      result = mock("result")
+      Vagrant::Action.expects(:new).with(env).returns(result).once
+      assert_equal result, env.actions
+      assert_equal result, env.actions
+      assert_equal result, env.actions
+    end
+  end
+
+  context "global data" do
+    should "lazy load the data store only once" do
+      env = vagrant_env
+      store = env.global_data
+
+      assert env.global_data.equal?(store)
+      assert env.global_data.equal?(store)
+      assert env.global_data.equal?(store)
+    end
+
+    should "return the parent's global data if a parent exists" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      result = env.global_data
+      assert env.vms[:web].env.global_data.equal?(result)
+    end
+  end
+
+  context "loading the root path" do
+    should "should walk the parent directories looking for rootfile" do
+      paths = [Pathname.new("/foo/bar/baz"),
+               Pathname.new("/foo/bar"),
+               Pathname.new("/foo"),
+               Pathname.new("/")
+              ]
+
+      rootfile = "Foo"
+
+      search_seq = sequence("search_seq")
+      paths.each do |path|
+        File.expects(:exist?).with(path.join(rootfile).to_s).returns(false).in_sequence(search_seq)
+        File.expects(:exist?).with(path).returns(true).in_sequence(search_seq) if !path.root?
+      end
+
+      assert !@klass.new(:cwd => paths.first, :vagrantfile_name => rootfile).root_path
+    end
+
+    should "should set the path for the rootfile" do
+      rootfile = "Foo"
+      path = Pathname.new(File.expand_path("/foo"))
+      File.expects(:exist?).with(path.join(rootfile).to_s).returns(true)
+
+      assert_equal path, @klass.new(:cwd => path, :vagrantfile_name => rootfile).root_path
+    end
+
+    should "not infinite loop on relative paths" do
+      assert @klass.new(:cwd => "../test").root_path.nil?
+    end
+
+    should "only load the root path once" do
+      rootfile = "foo"
+      env = @klass.new(:vagrantfile_name => rootfile)
+      File.expects(:exist?).with(env.cwd.join(rootfile).to_s).returns(true).once
+
+      assert_equal env.cwd, env.root_path
+      assert_equal env.cwd, env.root_path
+      assert_equal env.cwd, env.root_path
+    end
+
+    should "only load the root path once even if nil" do
+      File.stubs(:exist?).returns(false)
+
+      env = @klass.new
+      assert env.root_path.nil?
+      assert env.root_path.nil?
+      assert env.root_path.nil?
+    end
+  end
+
+  context "locking" do
+    setup do
+      @instance = @klass.new(:lock_path => Tempfile.new('vagrant-test').path)
+    end
+
+    should "allow nesting locks" do
+      assert_nothing_raised do
+        @instance.lock do
+          @instance.lock do
+            # Nothing
+          end
+        end
+      end
+    end
+
+    should "raise an exception if an environment already has a lock" do
+      @another = @klass.new(:lock_path => @instance.lock_path)
+
+      # Create first locked thread which should succeed
+      first = Thread.new do
+        begin
+          @instance.lock do
+            Thread.current[:locked] = true
+            loop { sleep 1000 }
+          end
+        rescue Vagrant::Errors::EnvironmentLockedError
+          Thread.current[:locked] = false
+        end
+      end
+
+      # Wait until the first thread has acquired the lock
+      loop do
+        break if first[:locked] || !first.alive?
+        Thread.pass
+      end
+
+      # Verify that the fist got the lock
+      assert first[:locked]
+
+      # Create second locked thread which should fail
+      second = Thread.new do
+        begin
+          @another.lock do
+            Thread.current[:error] = false
+          end
+        rescue Vagrant::Errors::EnvironmentLockedError
+          Thread.current[:error] = true
+        end
+      end
+
+      # Wait for the second to end and verify it failed
+      second.join
+      assert second[:error]
+
+      # Make sure both threads are killed
+      first.kill
+      second.kill
+    end
+  end
+
+  context "accessing the configuration" do
+    should "load the environment if its not already loaded" do
+      env = @klass.new(:cwd => vagrantfile)
+      env.expects(:load!).once
+      env.config
+    end
+
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.config
+    end
+  end
+
+  context "accessing the box collection" do
+    should "create a box collection representing the environment" do
+      env = vagrant_env
+      assert env.boxes.is_a?(Vagrant::BoxCollection)
+      assert_equal env, env.boxes.env
+    end
+
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.boxes
+    end
+
+    should "return the parent's box collection if it has one" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      assert env.vms[:web].env.boxes.equal?(env.boxes)
+    end
+  end
+
+  context "accessing the VMs hash" do
+    should "load the environment if its not already loaded" do
+      env = @klass.new(:cwd => vagrantfile)
+      assert !env.loaded?
+      env.vms
+      assert env.loaded?
+    end
+
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.vms
+    end
+
+    should "return the parent's VMs hash if it has one" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      assert env.vms[:web].env.vms.equal?(env.vms)
+    end
+  end
+
+  context "loading" do
+    context "overall load method" do
+      should "load! should call proper sequence and return itself" do
+        env = @klass.new(:cwd => vagrantfile)
+        call_seq = sequence("call_sequence")
+        @klass.expects(:check_virtualbox!).once.in_sequence(call_seq)
+        env.expects(:load_config!).once.in_sequence(call_seq)
+        assert_equal env, env.load!
+      end
+    end
+
+    context "loading config" do
+      setup do
+        clean_paths
+        @env = @klass.new(:cwd => vagrantfile)
+      end
+
+      def create_box_vagrantfile
+        vagrantfile(vagrant_box("box"), <<-FILE)
+          config.package.name = "box.box"
+          config.vm.base_mac = "set"
+        FILE
+      end
+
+      def create_home_vagrantfile
+        vagrantfile(home_path, 'config.package.name = "home.box"')
+      end
+
+      def create_root_vagrantfile
+        vagrantfile(@env.root_path, 'config.package.name = "root.box"')
+      end
+
+      should "load from the project root" do
+        assert_equal "package.box", @env.config.package.name
+      end
+
+      should "load from box if specified" do
+        create_box_vagrantfile
+        vagrantfile(@env.root_path, "config.vm.box = 'box'")
+
+        assert_equal "box.box", @env.primary_vm.env.config.package.name
+      end
+
+      should "load from home path if exists" do
+        create_home_vagrantfile
+        assert_equal "home.box", @env.config.package.name
+      end
+
+      should "load from root path" do
+        create_home_vagrantfile
+        create_root_vagrantfile
+        assert_equal "root.box", @env.config.package.name
+      end
+
+      should "load from a sub-vm configuration if environment represents a VM" do
+        create_home_vagrantfile
+        create_box_vagrantfile
+        vagrantfile(@env.root_path, <<-vf)
+          config.package.name = "root.box"
+          config.vm.define :web do |web|
+            web.vm.box = "box"
+            web.package.name = "web.box"
+          end
+        vf
+
+        assert_equal "root.box", @env.config.package.name
+        assert_equal "web.box", @env.vms[:web].env.config.package.name
+        assert_equal "set", @env.vms[:web].env.config.vm.base_mac
+      end
+
+      should "be able to reload config" do
+        vagrantfile(@env.root_path, "config.vm.box = 'box'")
+
+        # First load the config normally
+        @env.load_config!
+        assert_equal "box", @env.config.vm.box
+        assert_not_equal "set", @env.config.vm.base_mac
+
+        # Modify the Vagrantfile and reload it, then verify new results
+        # are available
+        vagrantfile(@env.root_path, "config.vm.base_mac = 'set'")
+        @env.reload_config!
+        assert_equal "set", @env.config.vm.base_mac
+      end
+    end
+
+    context "loading home directory" do
+      setup do
+        @env = vagrant_env
+
+        File.stubs(:directory?).returns(true)
+        FileUtils.stubs(:mkdir_p)
+      end
+
+      should "create each directory if it doesn't exist" do
+        create_seq = sequence("create_seq")
+        File.stubs(:directory?).returns(false)
+        @klass::HOME_SUBDIRS.each do |subdir|
+          FileUtils.expects(:mkdir_p).with(@env.home_path.join(subdir)).in_sequence(create_seq)
+        end
+
+        @env.load_home_directory!
+      end
+
+      should "not create directories if they exist" do
+        File.stubs(:directory?).returns(true)
+        FileUtils.expects(:mkdir_p).never
+        @env.load_home_directory!
+      end
+    end
+
+    context "loading the UUID out from the persisted dotfile" do
+      setup do
+        @env = vagrant_env
+      end
+
+      should "load all the VMs from the dotfile" do
+        @env.local_data[:active] = { "foo" => "bar", "bar" => "baz" }
+
+        results = {}
+        @env.local_data[:active].each do |key, value|
+          vm = mock("vm#{key}")
+          Vagrant::VM.expects(:find).with(value, @env, key.to_sym).returns(vm)
+          results[key.to_sym] = vm
+        end
+
+        returned = @env.load_vms!
+
+        results.each do |key, value|
+          assert_equal value, returned[key]
+        end
+      end
+
+      should "uuid should be nil if local data contains nothing" do
+        assert @env.local_data.empty? # sanity
+        @env.load_vms!
+        assert_nil @env.vm
+      end
+    end
+  end
+end