vagrant 0.5.4 → 0.6.0

data/test/vagrant/data_store_test.rb

@@ -0,0 +1,68 @@
+require "test_helper"
+
+class DataStoreTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::DataStore
+    @initial_data = { "foo" => "bar" }
+    @db_file = File.join(tmp_path, "data_store_test")
+    File.open(@db_file, "w") { |f| f.write(@initial_data.to_json) }
+
+    @instance = @klass.new(@db_file)
+  end
+
+  teardown do
+    File.delete(@db_file) if File.file?(@db_file)
+  end
+
+  should "be a hash with indifferent access" do
+    assert @instance.is_a?(Vagrant::Util::HashWithIndifferentAccess)
+  end
+
+  should "just be an empty hash if file doesn't exist" do
+    assert @klass.new("NEvERNENVENRNE").empty?
+  end
+
+  should "read the data" do
+    assert_equal @initial_data["foo"], @instance[:foo]
+  end
+
+  should "read the data by stringifying keys" do
+    @instance[:bar] = { "baz" => "yay" }
+    @instance.commit
+    @instance = @klass.new(@db_file)
+    assert_equal "yay", @instance[:bar]["baz"]
+  end
+
+  should "write the data, but not save it right away" do
+    @instance[:foo] = "changed"
+    assert_equal "changed", @instance[:foo]
+    assert_equal @initial_data["foo"], @klass.new(@db_file)["foo"]
+  end
+
+  should "write the data if commit is called" do
+    @instance[:foo] = "changed"
+    @instance.commit
+
+    assert_equal "changed", @klass.new(@db_file)[:foo]
+  end
+
+  should "delete the data store file if the hash is empty" do
+    @instance[:foo] = :bar
+    @instance.commit
+    assert File.exist?(@db_file)
+
+    @instance.clear
+    assert @instance.empty?
+    @instance.commit
+    assert !File.exist?(@db_file)
+  end
+
+  should "clean nil and empties if commit is called" do
+    @instance[:foo] = { :bar => nil }
+    @instance[:bar] = {}
+    @instance.commit
+
+    assert !@instance.has_key?(:foo)
+    assert !@instance.has_key?(:bar)
+  end
+end

data/test/vagrant/downloaders/base_test.rb

@@ -7,7 +7,7 @@ class BaseDownloaderTest < Test::Unit::TestCase
 
   context "base instance" do
     setup do
-      @env = mock_environment
+      @env = vagrant_env
       @base = Vagrant::Downloaders::Base.new(@env)
     end
 

data/test/vagrant/downloaders/file_test.rb

@@ -9,9 +9,10 @@ class FileDownloaderTest < Test::Unit::TestCase
   context "preparing" do
     should "raise an exception if the file does not exist" do
       File.expects(:file?).with(@uri).returns(false)
-      @downloader.prepare(@uri)
-      assert @downloader.env.error?
-      assert_equal :downloader_file_doesnt_exist, @downloader.env.error.first
+
+      assert_raises(Vagrant::Errors::DownloaderFileDoesntExist) {
+        @downloader.prepare(@uri)
+      }
     end
   end
 

data/test/vagrant/downloaders/http_test.rb

@@ -10,6 +10,8 @@ class HttpDownloaderTest < Test::Unit::TestCase
 
   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)
@@ -17,7 +19,15 @@ class HttpDownloaderTest < Test::Unit::TestCase
     end
 
     should "create a proper net/http object" do
-      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port).once.returns(@http)
+      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
@@ -45,10 +55,10 @@ class HttpDownloaderTest < Test::Unit::TestCase
 
     should "error environment if invalid URL given" do
       Net::HTTP.expects(:new).raises(SocketError.new)
-      @downloader.download!(@uri, @tempfile)
 
-      assert @downloader.env.error?
-      assert_equal :box_download_http_socket_error, @downloader.env.error.first
+      assert_raises(Vagrant::Errors::DownloaderHTTPSocketError) {
+        @downloader.download!(@uri, @tempfile)
+      }
     end
   end
 

data/test/vagrant/environment_test.rb

@@ -1,6 +1,11 @@
 require "test_helper"
+require "pathname"
 
 class EnvironmentTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Environment
+  end
+
   context "class method check virtualbox version" do
     setup do
       VirtualBox.stubs(:version).returns("3.1.4")
@@ -8,424 +13,409 @@ class EnvironmentTest < Test::Unit::TestCase
 
     should "not error and exit if everything is good" do
       VirtualBox.expects(:version).returns("3.2.4")
-      Vagrant::Environment.expects(:error_and_exit).never
-      Vagrant::Environment.check_virtualbox!
+      assert_nothing_raised { @klass.check_virtualbox! }
     end
 
     should "error and exit if VirtualBox is not installed or detected" do
-      Vagrant::Environment.expects(:error_and_exit).with(:virtualbox_not_detected).once
       VirtualBox.expects(:version).returns(nil)
-      Vagrant::Environment.check_virtualbox!
+      assert_raises(Vagrant::Errors::VirtualBoxNotDetected) { @klass.check_virtualbox! }
     end
 
     should "error and exit if VirtualBox is lower than version 3.2" do
       version = "3.1.12r1041"
-      Vagrant::Environment.expects(:error_and_exit).with(:virtualbox_invalid_version, :version => version.to_s).once
       VirtualBox.expects(:version).returns(version)
-      Vagrant::Environment.check_virtualbox!
+      assert_raises(Vagrant::Errors::VirtualBoxInvalidVersion) { @klass.check_virtualbox! }
     end
 
     should "error and exit for OSE VirtualBox" do
       version = "3.2.6_OSE"
-      Vagrant::Environment.expects(:error_and_exit).with(:virtualbox_invalid_ose, :version => version.to_s).once
       VirtualBox.expects(:version).returns(version)
-      Vagrant::Environment.check_virtualbox!
-    end
-  end
-
-  context "class method load!" do
-    setup do
-      @cwd = mock('cwd')
-
-      @env = mock('env')
-      @env.stubs(:load!).returns(@env)
-    end
-
-    should "create the environment with given cwd, load it, and return it" do
-      Vagrant::Environment.expects(:new).with(:cwd => @cwd).once.returns(@env)
-      @env.expects(:load!).returns(@env)
-      assert_equal @env, Vagrant::Environment.load!(@cwd)
-    end
-
-    should "work without a given cwd" do
-      Vagrant::Environment.expects(:new).with(:cwd => nil).returns(@env)
-
-      assert_nothing_raised {
-        env = Vagrant::Environment.load!
-        assert_equal env, @env
-      }
+      assert_raises(Vagrant::Errors::VirtualBoxInvalidOSE) { @klass.check_virtualbox! }
     end
   end
 
   context "initialization" do
     should "set the cwd if given" do
       cwd = "foobarbaz"
-      env = Vagrant::Environment.new(:cwd => cwd)
-      assert_equal cwd, env.cwd
+      env = @klass.new(:cwd => cwd)
+      assert_equal Pathname.new(cwd), env.cwd
     end
 
     should "default to pwd if cwd is nil" do
-      env = Vagrant::Environment.new
-      assert_equal Dir.pwd, env.cwd
+      env = @klass.new
+      assert_equal Pathname.new(Dir.pwd), env.cwd
     end
   end
 
   context "paths" do
     setup do
-      @env = mock_environment
-    end
-
-    context "cwd" do
-      should "default to Dir.pwd" do
-        assert_equal Dir.pwd, @env.cwd
-      end
-
-      should "return cwd if set" do
-        @env.cwd = "foo"
-        assert_equal "foo", @env.cwd
-      end
+      @env = vagrant_env
     end
 
     context "dotfile path" do
-      setup do
-        @env.stubs(:root_path).returns("foo")
-      end
-
       should "build up the dotfile out of the root path and the dotfile name" do
-        assert_equal File.join(@env.root_path, @env.config.vagrant.dotfile_name), @env.dotfile_path
+        assert_equal @env.root_path.join(@env.config.vagrant.dotfile_name), @env.dotfile_path
       end
     end
 
     context "home path" do
-      should "return nil if config is not yet loaded" do
-        @env.stubs(:config).returns(nil)
-        assert_nil @env.home_path
-      end
-
       should "return the home path if it loaded" do
-        assert_equal @env.config.vagrant.home, @env.home_path
+        expected = Pathname.new(File.expand_path(@env.config.vagrant.home, @env.root_path))
+        assert_equal expected, @env.home_path
       end
     end
 
     context "temp path" do
       should "return the home path joined with 'tmp'" do
-        home_path = "foo"
-        @env.stubs(:home_path).returns(home_path)
-        assert_equal File.join("foo", "tmp"), @env.tmp_path
+        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
-        home_path = "foo"
-        @env.stubs(:home_path).returns(home_path)
-        assert_equal File.join("foo", "boxes"), @env.boxes_path
+        assert_equal @env.home_path.join("boxes"), @env.boxes_path
       end
     end
   end
 
-  context "primary VM helper" do
+  context "resource" do
     setup do
-      @env = mock_environment
-      @env.stubs(:multivm?).returns(true)
+      @env = vagrant_env
     end
 
-    should "return the first VM if not multivm" do
-      result = mock("result")
+    should "return 'vagrant' as a default" do
+      assert_equal 'vagrant', @env.resource
+    end
 
-      @env.stubs(:multivm?).returns(false)
-      @env.stubs(:vms).returns({:default => result})
+    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
 
-      assert_equal result, @env.primary_vm
+  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
-      result = mock("result")
-      parent = mock("parent")
-      parent.expects(:primary_vm).returns(result)
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define(:web, :primary => true) do; end
+        config.vm.define :db do; end
+      vf
 
-      @env.stubs(:parent).returns(parent)
-      assert_equal result, @env.primary_vm
+      assert_equal :web, env.primary_vm.name
     end
 
     should "return nil if no VM is marked as primary" do
-      @env.config.vm.define(:foo)
-      @env.config.vm.define(:bar)
-      @env.config.vm.define(:baz)
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+        config.vm.define :utility
+      vf
 
-      assert @env.primary_vm.nil?
+      assert env.primary_vm.nil?
     end
+  end
 
-    should "return the primary VM" do
-      @env.config.vm.define(:foo)
-      @env.config.vm.define(:bar, :primary => true)
-      @env.config.vm.define(:baz)
+  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
 
-      result = mock("result")
-      vms = {
-        :foo => :foo,
-        :bar => result,
-        :baz => :baz
-      }
-      @env.stubs(:vms).returns(vms)
+      assert env.multivm?
+    end
+
+    should "return false if VM length is 1" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+      vf
 
-      assert_equal result, @env.primary_vm
+      assert !env.multivm?
     end
   end
 
-  context "multivm? helper" do
-    setup do
-      @env = mock_environment
+  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
 
-    context "with a parent" do
-      setup do
-        @parent = mock('parent')
-        @env.stubs(:parent).returns(@parent)
-      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
 
-      should "return the value of multivm? from the parent" do
-        result = mock("result")
-        @parent.stubs(:multivm?).returns(result)
-        assert_equal result, @env.multivm?
-      end
+      env.local_data[:foo] = :bar
+
+      Vagrant::DataStore.expects(:new).never
+      assert_equal :bar, env.vms[:web].env.local_data[:foo]
     end
+  end
 
-    context "without a parent" do
-      setup do
-        @env.stubs(:parent).returns(nil)
-      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
 
-      should "return true if VM length greater than 1" do
-        @env.stubs(:vms).returns([1,2,3])
-        assert @env.multivm?
-      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
 
-      should "return false if VM length is 1" do
-        @env.stubs(:vms).returns([1])
-        assert !@env.multivm?
-      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" do
-    setup do
-      @env = mock_environment
+  context "loading logger" do
+    should "lazy load the logger only once" do
+      result = Vagrant::Util::ResourceLogger.new("vagrant", vagrant_env)
+      Vagrant::Util::ResourceLogger.expects(:new).returns(result).once
+      env = vagrant_env
+      assert_equal result, env.logger
+      assert_equal result, env.logger
+      assert_equal result, env.logger
     end
 
-    context "overall load method" do
-      should "load! should call proper sequence and return itself" do
-        call_seq = sequence("call_sequence")
-        @env.expects(:load_logger!).once.in_sequence(call_seq)
-        @env.expects(:load_root_path!).once.in_sequence(call_seq)
-        @env.expects(:load_config!).once.in_sequence(call_seq)
-        @env.expects(:load_home_directory!).once.in_sequence(call_seq)
-        @env.expects(:load_host!).once.in_sequence(call_seq)
-        @env.expects(:load_box!).once.in_sequence(call_seq)
-        @env.expects(:load_config!).once.in_sequence(call_seq)
-        Vagrant::Environment.expects(:check_virtualbox!).once.in_sequence(call_seq)
-        @env.expects(:load_vm!).once.in_sequence(call_seq)
-        @env.expects(:load_active_list!).once.in_sequence(call_seq)
-        @env.expects(:load_commands!).once.in_sequence(call_seq)
-        @env.expects(:load_actions!).once.in_sequence(call_seq)
-        assert_equal @env, @env.load!
-      end
+    should "return the parent's logger if a parent exists" do
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.define :web
+        config.vm.define :db
+      vf
+
+      result = env.logger
+
+      Vagrant::Util::ResourceLogger.expects(:new).never
+      assert env.vms[:web].env.logger.equal?(result)
     end
+  end
 
-    context "loading the root path" do
-      setup do
-        @env.cwd = "/foo"
-      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("/")
+              ]
 
-      should "default the path to the cwd instance var if nil" do
-        @path = mock("path")
-        @path.stubs(:root?).returns(true)
-        File.expects(:expand_path).with(@env.cwd).returns(@env.cwd)
-        Pathname.expects(:new).with(@env.cwd).returns(@path)
-        @env.load_root_path!(nil)
+      search_seq = sequence("search_seq")
+      paths.each do |path|
+        File.expects(:exist?).with(path.join(@klass::ROOTFILE_NAME).to_s).returns(false).in_sequence(search_seq)
       end
 
-      should "not default the path to pwd if its not nil" do
-        @path = mock("path")
-        @path.stubs(:to_s).returns("/")
-        File.expects(:expand_path).with(@path).returns("/")
-        Pathname.expects(:new).with("/").returns(@path)
-        @path.stubs(:root?).returns(true)
-        @env.load_root_path!(@path)
-      end
+      assert !@klass.new(:cwd => paths.first).root_path
+    end
 
-      should "should walk the parent directories looking for rootfile" do
-        paths = [
-          Pathname.new("/foo/bar/baz"),
-          Pathname.new("/foo/bar"),
-          Pathname.new("/foo")
-        ]
-
-        search_seq = sequence("search_seq")
-        paths.each do |path|
-          # NOTE File.expect(:expand_path) causes tests to hang in windows below is the interim solution
-          File.expects(:exist?).with("#{File.expand_path(path)}/#{Vagrant::Environment::ROOTFILE_NAME}").returns(false).in_sequence(search_seq)
-        end
+    should "should set the path for the rootfile" do
+      path = Pathname.new(File.expand_path("/foo"))
+      File.expects(:exist?).with(path.join(@klass::ROOTFILE_NAME).to_s).returns(true)
 
-        assert !@env.load_root_path!(paths.first)
-      end
+      assert_equal path, @klass.new(:cwd => path).root_path
+    end
 
-      should "return false if not found" do
-        path = Pathname.new("/")
-        assert !@env.load_root_path!(path)
-      end
+    should "only load the root path once" do
+      env = @klass.new
+      File.expects(:exist?).with(env.cwd.join(@klass::ROOTFILE_NAME).to_s).returns(true).once
 
-      should "return false if not found on windows-style root" do
-        # TODO: Is there _any_ way to test this on unix machines? The
-        # expand path doesn't work [properly for the test] on unix machines.
-        if RUBY_PLATFORM.downcase.include?("mswin")
-          # Note the escaped back slash
-          path = Pathname.new("C:\\")
-          assert !@env.load_root_path!(path)
-        end
-      end
+      assert_equal env.cwd, env.root_path
+      assert_equal env.cwd, env.root_path
+      assert_equal env.cwd, env.root_path
+    end
 
-      should "should set the path for the rootfile" do
-        # NOTE File.expect(:expand_path) causes tests to hang in windows below is the interim solution
-        path = File.expand_path("/foo")
-        File.expects(:exist?).with("#{path}/#{Vagrant::Environment::ROOTFILE_NAME}").returns(true)
+    should "only load the root path once even if nil" do
+      File.stubs(:exist?).returns(false)
 
-        assert @env.load_root_path!(Pathname.new(path))
-        assert_equal path, @env.root_path
-      end
+      env = @klass.new
+      assert env.root_path.nil?
+      assert env.root_path.nil?
+      assert env.root_path.nil?
     end
+  end
 
-    context "loading config" do
-      setup do
-        @root_path = "/foo"
-        @home_path = "/bar"
-        @env.stubs(:root_path).returns(@root_path)
-        @env.stubs(:home_path).returns(@home_path)
-        @env.stubs(:load_logger!)
+  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
 
-        @parent_env = mock_environment
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.config
+    end
+  end
 
-        File.stubs(:exist?).returns(false)
-      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 "reset the configuration object" do
-        Vagrant::Config.expects(:reset!).with(@env).once
-        @env.load_config!
-      end
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.boxes
+    end
 
-      should "load from the project root" do
-        File.expects(:exist?).with(File.join(PROJECT_ROOT, "config", "default.rb")).once
-        @env.load_config!
-      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
 
-      should "load from the root path" do
-        File.expects(:exist?).with(File.join(@root_path, Vagrant::Environment::ROOTFILE_NAME)).once
-        @env.load_config!
-      end
+      assert env.vms[:web].env.boxes.equal?(env.boxes)
+    end
+  end
 
-      should "not load from the root path if nil" do
-        @env.stubs(:root_path).returns(nil)
-        File.expects(:exist?).with(File.join(@root_path, Vagrant::Environment::ROOTFILE_NAME)).never
-        @env.load_config!
-      end
+  context "accessing the current box" do
+    should "return the box that is specified in the config" do
+      vagrant_box("foo")
+      env = vagrant_env(vagrantfile(<<-vf))
+        config.vm.box = "foo"
+      vf
 
-      should "load from the home directory" do
-        File.expects(:exist?).with(File.join(@env.home_path, Vagrant::Environment::ROOTFILE_NAME)).once
-        @env.load_config!
-      end
+      assert env.box
+      assert_equal "foo", env.box.name
+    end
+  end
 
-      should "not load from the home directory if the config is nil" do
-        @env.stubs(:home_path).returns(nil)
-        File.expects(:exist?).twice.returns(false)
-        @env.load_config!
-      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 from the box directory if it is nil" do
-        @env.expects(:box).once.returns(nil)
-        File.expects(:exist?).twice.returns(false)
-        @env.load_config!
-      end
+    should "not load the environment if its already loaded" do
+      env = vagrant_env
+      env.expects(:load!).never
+      env.vms
+    end
 
-      should "load from the box directory if it is not nil" do
-        dir = "foo"
-        box = mock("box")
-        box.stubs(:directory).returns(dir)
-        @env.expects(:box).twice.returns(box)
-        File.expects(:exist?).with(File.join(dir, Vagrant::Environment::ROOTFILE_NAME)).once
-        @env.load_config!
-      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
 
-      should "load a sub-VM configuration if specified" do
-        vm_name = :foo
-        sub_box = :YO
-        @parent_env.config.vm.box = :NO
-        @parent_env.config.vm.define(vm_name) do |config|
-          config.vm.box = sub_box
-        end
+      assert env.vms[:web].env.vms.equal?(env.vms)
+    end
+  end
 
-        # Sanity
-        assert_equal :NO, @parent_env.config.vm.box
+  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)
+        env.actions.expects(:run).with(:environment_load).once.in_sequence(call_seq)
+        assert_equal env, env.load!
+      end
+    end
 
-        @env.stubs(:vm_name).returns(vm_name)
-        @env.stubs(:parent).returns(@parent_env)
+    context "loading config" do
+      setup do
+        clean_paths
+        @env = @klass.new(:cwd => vagrantfile)
+      end
 
-        @env.load_config!
+      def create_box_vagrantfile
+        vagrantfile(vagrant_box("box"), 'config.package.name = "box.box"')
+      end
 
-        assert_equal sub_box, @env.config.vm.box
+      def create_home_vagrantfile
+        vagrantfile(home_path, 'config.package.name = "home.box"')
       end
 
-      should "load the files only if exist? returns true" do
-        File.expects(:exist?).once.returns(true)
-        @env.expects(:load).once
-        @env.load_config!
+      def create_root_vagrantfile
+        vagrantfile(@env.root_path, 'config.package.name = "root.box"')
       end
 
-      should "not load the files if exist? returns false" do
-        @env.expects(:load).never
-        @env.load_config!
+      should "load from the project root" do
+        assert_equal "package.box", @env.config.package.name
       end
 
-      should "execute after loading and set result to environment config" do
-        result = mock("result")
-        File.expects(:exist?).once.returns(true)
-        @env.expects(:load).once
-        Vagrant::Config.expects(:execute!).once.returns(result)
-        @env.load_config!
-        assert_equal result, @env.config
+      should "load from box if specified" do
+        create_box_vagrantfile
+        vagrantfile(@env.root_path, "config.vm.box = 'box'")
+
+        assert_equal "box.box", @env.config.package.name
       end
 
-      should "reload the logger after executing" do
-        load_seq = sequence("load_seq")
-        Vagrant::Config.expects(:execute!).once.returns(nil).in_sequence(load_seq)
-        @env.expects(:load_logger!).once.in_sequence(load_seq)
-        @env.load_config!
+      should "load from home path if exists" do
+        create_home_vagrantfile
+        assert_equal "home.box", @env.config.package.name
       end
-    end
 
-    context "loading logger" do
-      setup do
-        @env = mock_environment
-        @env.stubs(:vm_name).returns(nil)
+      should "load from root path" do
+        create_home_vagrantfile
+        create_root_vagrantfile
+        assert_equal "root.box", @env.config.package.name
       end
 
-      should "use 'vagrant' by default" do
-        assert @env.vm_name.nil? # sanity
-        @env.load_logger!
-        assert_equal "vagrant", @env.logger.resource
+      should "load from a sub-vm configuration if environment represents a VM" do
+        create_home_vagrantfile
+        vagrantfile(@env.root_path, <<-vf)
+          config.package.name = "root.box"
+          config.vm.define :web do |web|
+            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
       end
 
-      should "use the vm name if available" do
-        name = "foo"
-        @env.stubs(:vm_name).returns(name)
-        @env.load_logger!
-        assert_equal name, @env.logger.resource
+      should "reload the logger after executing" do
+        @env.load_config!
+        assert @env.instance_variable_get(:@logger).nil?
       end
     end
 
     context "loading home directory" do
       setup do
-        @env = mock_environment
-        @home_dir = File.expand_path(@env.config.vagrant.home)
+        @env = vagrant_env
 
         File.stubs(:directory?).returns(true)
         FileUtils.stubs(:mkdir_p)
@@ -434,8 +424,8 @@ class EnvironmentTest < Test::Unit::TestCase
       should "create each directory if it doesn't exist" do
         create_seq = sequence("create_seq")
         File.stubs(:directory?).returns(false)
-        Vagrant::Environment::HOME_SUBDIRS.each do |subdir|
-          FileUtils.expects(:mkdir_p).with(File.join(@home_dir, subdir)).in_sequence(create_seq)
+        @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!
@@ -448,323 +438,33 @@ class EnvironmentTest < Test::Unit::TestCase
       end
     end
 
-    context "loading host" do
-      setup do
-        @env = mock_environment
-      end
-
-      should "load the host by calling the load method on Host::Base" do
-        result = mock("result")
-        Vagrant::Hosts::Base.expects(:load).with(@env, @env.config.vagrant.host).once.returns(result)
-        @env.load_host!
-        assert_equal result, @env.host
-      end
-    end
-
-    context "loading box" do
-      setup do
-        @box = mock("box")
-        @box.stubs(:env=)
-
-        @env = mock_environment
-        @env.stubs(:root_path).returns("foo")
-      end
-
-      should "do nothing if the root path is nil" do
-        Vagrant::Box.expects(:find).never
-        @env.stubs(:root_path).returns(nil)
-        @env.load_box!
-      end
-
-      should "not load the box if its not set" do
-        @env = mock_environment do |config|
-          config.vm.box = nil
-        end
-
-        Vagrant::Box.expects(:find).never
-        @env.load_box!
-      end
-
-      should "set the box to what is found by the Box class" do
-        Vagrant::Box.expects(:find).with(@env, @env.config.vm.box).once.returns(@box)
-        @env.load_box!
-        assert @box.equal?(@env.box)
-      end
-    end
-
     context "loading the UUID out from the persisted dotfile" do
       setup do
-        @env = mock_environment
-        @env.stubs(:root_path).returns("foo")
-
-        File.stubs(:file?).returns(true)
-      end
-
-      should "blank the VMs" do
-        load_seq = sequence("load_seq")
-        @env.stubs(:root_path).returns("foo")
-        @env.expects(:load_blank_vms!).in_sequence(load_seq)
-        File.expects(:open).in_sequence(load_seq)
-        @env.load_vm!
-      end
-
-      should "load the UUID if the JSON parsing fails" do
-        vm = mock("vm")
-
-        filemock = mock("filemock")
-        filemock.expects(:read).returns("foo")
-        Vagrant::VM.expects(:find).with("foo", @env, Vagrant::Environment::DEFAULT_VM).returns(vm)
-        File.expects(:open).with(@env.dotfile_path).once.yields(filemock)
-        File.expects(:file?).with(@env.dotfile_path).once.returns(true)
-        @env.load_vm!
-
-        assert_equal vm,  @env.vms.values.first
+        @env = vagrant_env
       end
 
       should "load all the VMs from the dotfile" do
-        vms = { :foo => "bar", :bar => "baz" }
-        results = {}
-
-        filemock = mock("filemock")
-        filemock.expects(:read).returns(vms.to_json)
-        File.expects(:open).with(@env.dotfile_path).once.yields(filemock)
-        File.expects(:file?).with(@env.dotfile_path).once.returns(true)
+        @env.local_data[:active] = { "foo" => "bar", "bar" => "baz" }
 
-        vms.each do |key, value|
+        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] = vm
+          results[key.to_sym] = vm
         end
 
-        @env.load_vm!
+        returned = @env.load_vms!
 
         results.each do |key, value|
-          assert_equal value, @env.vms[key]
+          assert_equal value, returned[key]
         end
       end
 
-      should "do nothing if the vm_name is set" do
-        @env.stubs(:vm_name).returns(:foo)
-        File.expects(:open).never
-        @env.load_vm!
-      end
-
-      should "do nothing if the dotfile is nil" do
-        @env.stubs(:dotfile_path).returns(nil)
-        File.expects(:open).never
-
-        assert_nothing_raised {
-          @env.load_vm!
-        }
-      end
-
-      should "do nothing if dotfile is not a file" do
-        File.expects(:file?).returns(false)
-        File.expects(:open).never
-        @env.load_vm!
-      end
-
-      should "uuid should be nil if dotfile didn't exist" do
-        File.expects(:open).raises(Errno::ENOENT)
-        @env.load_vm!
+      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
-
-    context "loading blank VMs" do
-      setup do
-        @env = mock_environment
-      end
-
-      should "blank the VMs" do
-        @env = mock_environment do |config|
-          config.vm.define :foo do |config|
-          end
-
-          config.vm.define :bar do |config|
-          end
-        end
-
-        @env.load_blank_vms!
-
-        assert_equal 2, @env.vms.length
-        assert(@env.vms.all? { |name, vm| !vm.created? })
-
-        sorted_vms = @env.vms.keys.sort { |a,b| a.to_s <=> b.to_s }
-        assert_equal [:bar, :foo], sorted_vms
-      end
-
-      should "load the default VM blank if no multi-VMs are specified" do
-        assert @env.config.vm.defined_vms.empty? # sanity
-
-        @env.load_blank_vms!
-
-        assert_equal 1, @env.vms.length
-        assert !@env.vms.values.first.created?
-      end
-    end
-
-    context "loading the active list" do
-      setup do
-        @env = mock_environment
-      end
-
-      should "initialize the ActiveList object with the given environment" do
-        active_list = mock("active_list")
-        Vagrant::ActiveList.expects(:new).with(@env).returns(active_list)
-        @env.load_active_list!
-        assert_equal active_list, @env.active_list
-      end
-    end
-
-    context "loading the commands" do
-      setup do
-        @env = mock_environment
-      end
-
-      should "initialize the Commands object with the given environment" do
-        commands = mock("commands")
-        Vagrant::Command.expects(:new).with(@env).returns(commands)
-        @env.load_commands!
-        assert_equal commands, @env.commands
-      end
-    end
-
-    context "loading actions" do
-      setup do
-        @env = mock_environment
-      end
-
-      should "initialize the Action object with the given environment" do
-        result = mock("result")
-        Vagrant::Action.expects(:new).with(@env).returns(result)
-        @env.load_actions!
-        assert_equal result, @env.actions
-      end
-    end
-  end
-
-  context "requiring properties" do
-    setup do
-      @env = mock_environment
-    end
-
-    context "requiring root_path" do
-      should "error and exit if no root_path is set" do
-        @env.expects(:root_path).returns(nil)
-        @env.expects(:error_and_exit).with(:rootfile_not_found).once
-        @env.require_root_path
-      end
-
-      should "not error and exit if root_path is set" do
-        @env.expects(:root_path).returns("foo")
-        @env.expects(:error_and_exit).never
-        @env.require_root_path
-      end
-    end
-
-    context "requiring a persisted VM" do
-      setup do
-        @env.stubs(:vm).returns("foo")
-        @env.stubs(:require_root_path)
-      end
-
-      should "require a root path" do
-        @env.expects(:require_root_path).once
-        @env.expects(:error_and_exit).never
-        @env.require_persisted_vm
-      end
-
-      should "error and exit if the VM is not set" do
-        @env.expects(:vm).returns(nil)
-        @env.expects(:error_and_exit).once
-        @env.require_persisted_vm
-      end
-    end
-  end
-
-  context "managing VM" do
-    setup do
-      @env = mock_environment
-
-      @dotfile_path = "foo"
-      @env.stubs(:dotfile_path).returns(@dotfile_path)
-    end
-
-    def mock_vm
-      @vm = mock("vm")
-      @vm.stubs(:uuid).returns("foo")
-      @env.stubs(:vm).returns(@vm)
-    end
-  end
-
-  context "updating the dotfile" do
-    setup do
-      @env = mock_environment
-      @env.stubs(:parent).returns(nil)
-      @env.stubs(:dotfile_path).returns("foo")
-      File.stubs(:open)
-      File.stubs(:exist?).returns(true)
-    end
-
-    def create_vm(created)
-      vm = mock("vm")
-      vm.stubs(:created?).returns(created)
-      vm.stubs(:uuid).returns("foo")
-      vm
-    end
-
-    should "call parent if exists" do
-      parent = mock("parent")
-      @env.stubs(:parent).returns(parent)
-      parent.expects(:update_dotfile).once
-
-      @env.update_dotfile
-    end
-
-    should "remove the dotfile if the data is empty" do
-      vms = {
-        :foo => create_vm(false)
-      }
-
-      @env.stubs(:vms).returns(vms)
-      File.expects(:delete).with(@env.dotfile_path).once
-      @env.update_dotfile
-    end
-
-    should "not remove the dotfile if it doesn't exist" do
-      vms = {
-        :foo => create_vm(false)
-      }
-
-      @env.stubs(:vms).returns(vms)
-      File.expects(:exist?).with(@env.dotfile_path).returns(false)
-      File.expects(:delete).never
-      assert_nothing_raised { @env.update_dotfile }
-    end
-
-    should "write the proper data to dotfile" do
-      vms = {
-        :foo => create_vm(false),
-        :bar => create_vm(true),
-        :baz => create_vm(true)
-      }
-
-      f = mock("f")
-      @env.stubs(:vms).returns(vms)
-      File.expects(:open).with(@env.dotfile_path, 'w+').yields(f)
-      f.expects(:write).with() do |json|
-        assert_nothing_raised {
-          data = JSON.parse(json)
-          assert_equal 2, data.length
-          assert_equal vms[:bar].uuid, data["bar"]
-          assert_equal vms[:baz].uuid, data["baz"]
-        }
-
-        true
-      end
-
-      @env.update_dotfile
-    end
   end
 end