vagrantup 0.3.4 → 0.4.0

data/test/vagrant/config_test.rb

@@ -52,17 +52,6 @@ class ConfigTest < Test::Unit::TestCase
     end
   end
 
-  context "accessing configuration" do
-    setup do
-      Vagrant::Config.run { |config| }
-      Vagrant::Config.execute!
-    end
-
-    should "forward config to the class method" do
-      assert_equal Vagrant.config, Vagrant::Config.config
-    end
-  end
-
   context "initializing" do
     setup do
       Vagrant::Config.reset!
@@ -92,7 +81,14 @@ class ConfigTest < Test::Unit::TestCase
     should "return the configuration on execute!" do
       Vagrant::Config.run {}
       result = Vagrant::Config.execute!
-      assert result.equal?(Vagrant.config)
+      assert result.is_a?(Vagrant::Config::Top)
+    end
+
+    should "use given configuration object if given" do
+      fake_env = mock("env")
+      config = Vagrant::Config::Top.new(fake_env)
+      result = Vagrant::Config.execute!(config)
+      assert_equal config.env, result.env
     end
   end
 
@@ -229,14 +225,74 @@ class ConfigTest < Test::Unit::TestCase
       @env.config.ssh.username = @username
     end
 
-    should "include the stacked proc runner module" do
-      assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
+    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 "not have multi-VMs by default" do
+        assert !@config.has_multi_vms?
+      end
+
+      should "have multi-VMs once one is specified" do
+        @config.define(:foo) {}
+        assert @config.has_multi_vms?
+      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_equal [proc], @config.proc_stack
+      end
     end
 
-    should "add the customize proc to the proc stack" do
-      proc = Proc.new {}
-      @config.customize(&proc)
-      assert_equal [proc], @config.proc_stack
+    context "syncd folders" do
+      should "set the syncpath to nil by default" do
+        share_with_opts
+        assert !@config.shared_folders['foo'][:syncpath]
+      end
+
+      should "append sync to directory name when boolean" do
+        share_with_opts(:sync => true)
+        assert_equal @config.shared_folders['foo'][:syncpath], 'foo-dir'
+        assert_equal @config.shared_folders['foo'][:guestpath], 'foo-dir-sync'
+      end
+
+      should "use the specified sync directory" do
+        share_with_opts(:sync => 'bar-baz')
+        assert_equal @config.shared_folders['foo'][:syncpath], 'bar-baz'
+      end
+
+      should "raise an exception an exception if the guestpath and syncpath are the same" do
+        assert_raise Exception do
+          share_with_opts(:sync => 'foo-dir-sync')
+        end
+      end
+
+      should "set the sync required flag to true" do
+        share_with_opts(:sync => true)
+        assert @config.sync_required
+      end
+
+      def share_with_opts(opts={})
+        @config.share_folder('foo', 'foo-dir', '', opts)
+      end
     end
 
     context "uid/gid" do

data/test/vagrant/downloaders/base_test.rb

@@ -7,7 +7,8 @@ class BaseDownloaderTest < Test::Unit::TestCase
 
   context "base instance" do
     setup do
-      @base = Vagrant::Downloaders::Base.new
+      @env = mock_environment
+      @base = Vagrant::Downloaders::Base.new(@env)
     end
 
     should "implement prepare which does nothing" do

data/test/vagrant/downloaders/http_test.rb

@@ -5,28 +5,38 @@ class HttpDownloaderTest < Test::Unit::TestCase
     @downloader, @tempfile = mock_downloader(Vagrant::Downloaders::HTTP)
     @downloader.stubs(:report_progress)
     @downloader.stubs(:complete_progress)
-    @uri = "foo.box"
+    @uri = "http://google.com/"
   end
 
   context "downloading" do
     setup do
-      @parsed_uri = mock("parsed")
-      URI.stubs(:parse).with(@uri).returns(@parsed_uri)
+      @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 "parse the URI and use that parsed URI for Net::HTTP" do
-      URI.expects(:parse).with(@uri).returns(@parsed_uri).once
-      Net::HTTP.expects(:get_response).with(@parsed_uri).once
+    should "create a proper net/http object" do
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port).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)
       segment = mock("segment")
       segment.stubs(:length).returns(7)
 
-      Net::HTTP.stubs(:get_response).yields(response)
+      @http.stubs(:start).yields(h)
+      h.expects(:request_get).with(@parsed_uri.request_uri).once.yields(response)
       response.expects(:read_body).once.yields(segment)
       @tempfile.expects(:write).with(segment).once
 
@@ -43,7 +53,7 @@ class HttpDownloaderTest < Test::Unit::TestCase
     should "return false if there are no extract results" do
       URI.expects(:extract).returns([])
       assert !Vagrant::Downloaders::HTTP.match?('foo')
-    end    
+    end
   end
 
   context "reporting progress" do

data/test/vagrant/environment_test.rb

@@ -42,13 +42,13 @@ class EnvironmentTest < Test::Unit::TestCase
     end
 
     should "create the environment with given cwd, load it, and return it" do
-      Vagrant::Environment.expects(:new).with(@cwd).once.returns(@env)
+      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(nil).returns(@env)
+      Vagrant::Environment.expects(:new).with(:cwd => nil).returns(@env)
 
       assert_nothing_raised {
         env = Vagrant::Environment.load!
@@ -60,7 +60,7 @@ class EnvironmentTest < Test::Unit::TestCase
   context "initialization" do
     should "set the cwd if given" do
       cwd = "foobarbaz"
-      env = Vagrant::Environment.new(cwd)
+      env = Vagrant::Environment.new(:cwd => cwd)
       assert_equal cwd, env.cwd
     end
 
@@ -124,6 +124,90 @@ class EnvironmentTest < Test::Unit::TestCase
     end
   end
 
+  context "primary VM helper" do
+    setup do
+      @env = mock_environment
+      @env.stubs(:multivm?).returns(true)
+    end
+
+    should "return the first VM if not multivm" do
+      result = mock("result")
+
+      @env.stubs(:multivm?).returns(false)
+      @env.stubs(:vms).returns({:default => result})
+
+      assert_equal result, @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.stubs(:parent).returns(parent)
+      assert_equal result, @env.primary_vm
+    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)
+
+      assert @env.primary_vm.nil?
+    end
+
+    should "return the primary VM" do
+      @env.config.vm.define(:foo)
+      @env.config.vm.define(:bar, :primary => true)
+      @env.config.vm.define(:baz)
+
+      result = mock("result")
+      vms = {
+        :foo => :foo,
+        :bar => result,
+        :baz => :baz
+      }
+      @env.stubs(:vms).returns(vms)
+
+      assert_equal result, @env.primary_vm
+    end
+  end
+
+  context "multivm? helper" do
+    setup do
+      @env = mock_environment
+    end
+
+    context "with a parent" do
+      setup do
+        @parent = mock('parent')
+        @env.stubs(:parent).returns(@parent)
+      end
+
+      should "return the value of multivm? from the parent" do
+        result = mock("result")
+        @parent.stubs(:multivm?).returns(result)
+        assert_equal result, @env.multivm?
+      end
+    end
+
+    context "without a parent" do
+      setup do
+        @env.stubs(:parent).returns(nil)
+      end
+
+      should "return true if VM length greater than 1" do
+        @env.stubs(:vms).returns([1,2,3])
+        assert @env.multivm?
+      end
+
+      should "return false if VM length is 1" do
+        @env.stubs(:vms).returns([1])
+        assert !@env.multivm?
+      end
+    end
+  end
+
   context "loading" do
     setup do
       @env = mock_environment
@@ -132,6 +216,7 @@ class EnvironmentTest < Test::Unit::TestCase
     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)
@@ -139,7 +224,6 @@ class EnvironmentTest < Test::Unit::TestCase
         @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_ssh!).once.in_sequence(call_seq)
         @env.expects(:load_active_list!).once.in_sequence(call_seq)
         @env.expects(:load_commands!).once.in_sequence(call_seq)
         assert_equal @env, @env.load!
@@ -215,10 +299,11 @@ class EnvironmentTest < Test::Unit::TestCase
         @home_path = "/bar"
         @env.stubs(:root_path).returns(@root_path)
         @env.stubs(:home_path).returns(@home_path)
+        @env.stubs(:load_logger!)
+
+        @parent_env = mock_environment
 
         File.stubs(:exist?).returns(false)
-        Vagrant::Config.stubs(:execute!)
-        Vagrant::Config.stubs(:reset!)
       end
 
       should "reset the configuration object" do
@@ -268,6 +353,25 @@ class EnvironmentTest < Test::Unit::TestCase
         @env.load_config!
       end
 
+      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
+
+        # Sanity
+        assert_equal :NO, @parent_env.config.vm.box
+
+        @env.stubs(:vm_name).returns(vm_name)
+        @env.stubs(:parent).returns(@parent_env)
+
+        @env.load_config!
+
+        assert_equal sub_box, @env.config.vm.box
+      end
+
       should "load the files only if exist? returns true" do
         File.expects(:exist?).once.returns(true)
         @env.expects(:load).once
@@ -287,6 +391,33 @@ class EnvironmentTest < Test::Unit::TestCase
         @env.load_config!
         assert_equal result, @env.config
       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!
+      end
+    end
+
+    context "loading logger" do
+      setup do
+        @env = mock_environment
+        @env.stubs(:vm_name).returns(nil)
+      end
+
+      should "use 'vagrant' by default" do
+        assert @env.vm_name.nil? # sanity
+        @env.load_logger!
+        assert_equal "vagrant", @env.logger.resource
+      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
+      end
     end
 
     context "loading home directory" do
@@ -354,37 +485,64 @@ class EnvironmentTest < Test::Unit::TestCase
         File.stubs(:file?).returns(true)
       end
 
-      should "loading of the uuid from the dotfile" do
+      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")
-        vm.expects(:env=).with(@env)
 
         filemock = mock("filemock")
         filemock.expects(:read).returns("foo")
-        Vagrant::VM.expects(:find).with("foo").returns(vm)
+        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.vm
+        assert_equal vm,  @env.vms.values.first
       end
 
-      should "not set the environment if the VM is nil" do
+      should "load all the VMs from the dotfile" do
+        vms = { :foo => "bar", :bar => "baz" }
+        results = {}
+
         filemock = mock("filemock")
-        filemock.expects(:read).returns("foo")
-        Vagrant::VM.expects(:find).with("foo").returns(nil)
+        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)
 
-        assert_nothing_raised { @env.load_vm! }
-        assert_nil @env.vm
+        vms.each do |key, value|
+          vm = mock("vm#{key}")
+          Vagrant::VM.expects(:find).with(value, @env, key.to_sym).returns(vm)
+          results[key] = vm
+        end
+
+        @env.load_vm!
+
+        results.each do |key, value|
+          assert_equal value, @env.vms[key]
+        end
       end
 
-      should "do nothing if the root path is nil" do
+      should "do nothing if the vm_name is set" do
+        @env.stubs(:vm_name).returns(:foo)
         File.expects(:open).never
-        @env.stubs(:root_path).returns(nil)
         @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
@@ -398,16 +556,36 @@ class EnvironmentTest < Test::Unit::TestCase
       end
     end
 
-    context "loading SSH" do
+    context "loading blank VMs" do
       setup do
         @env = mock_environment
       end
 
-      should "initialize the SSH object with the given environment" do
-        ssh = mock("ssh")
-        Vagrant::SSH.expects(:new).with(@env).returns(ssh)
-        @env.load_ssh!
-        assert_equal ssh, @env.ssh
+      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
 
@@ -530,73 +708,63 @@ class EnvironmentTest < Test::Unit::TestCase
       @vm.stubs(:uuid).returns("foo")
       @env.stubs(:vm).returns(@vm)
     end
+  end
 
-    context "creating a new VM" do
-      should "create a new VM" do
-        assert_nil @env.vm
-        @env.create_vm
-        assert !@env.vm.nil?
-        assert @env.vm.is_a?(Vagrant::VM)
-      end
-
-      should "set the new VM's environment to the env" do
-        @env.create_vm
-        assert_equal @env, @env.vm.env
-      end
-
-      should "return the new VM" do
-        result = @env.create_vm
-        assert result.is_a?(Vagrant::VM)
-      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)
     end
 
-    context "persisting the VM into a file" do
-      setup do
-        mock_vm
-
-        File.stubs(:open)
-        @env.active_list.stubs(:add)
-      end
+    def create_vm(created)
+      vm = mock("vm")
+      vm.stubs(:created?).returns(created)
+      vm.stubs(:uuid).returns("foo")
+      vm
+    end
 
-      should "should save it to the dotfile path" do
-        filemock = mock("filemock")
-        filemock.expects(:write).with(@vm.uuid)
-        File.expects(:open).with(@env.dotfile_path, 'w+').once.yields(filemock)
-        @env.persist_vm
-      end
+    should "call parent if exists" do
+      parent = mock("parent")
+      @env.stubs(:parent).returns(parent)
+      parent.expects(:update_dotfile).once
 
-      should "add the VM to the activelist" do
-        @env.active_list.expects(:add).with(@vm)
-        @env.persist_vm
-      end
+      @env.update_dotfile
     end
 
-    context "depersisting the VM" do
-      setup do
-        mock_vm
+    should "remove the dotfile if the data is empty" do
+      vms = {
+        :foo => create_vm(false)
+      }
 
-        File.stubs(:exist?).returns(false)
-        File.stubs(:delete)
+      @env.stubs(:vms).returns(vms)
+      File.expects(:delete).with(@env.dotfile_path).once
+      @env.update_dotfile
+    end
 
-        @env.active_list.stubs(:remove)
-      end
+    should "write the proper data to dotfile" do
+      vms = {
+        :foo => create_vm(false),
+        :bar => create_vm(true),
+        :baz => create_vm(true)
+      }
 
-      should "remove the dotfile if it exists" do
-        File.expects(:exist?).with(@env.dotfile_path).returns(true)
-        File.expects(:delete).with(@env.dotfile_path).once
-        @env.depersist_vm
-      end
+      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"]
+        }
 
-      should "not remove the dotfile if it doesn't exist" do
-        File.expects(:exist?).returns(false)
-        File.expects(:delete).never
-        @env.depersist_vm
+        true
       end
 
-      should "remove from the active list" do
-        @env.active_list.expects(:remove).with(@vm)
-        @env.depersist_vm
-      end
+      @env.update_dotfile
     end
   end
 end