vagrant 0.2.0 → 0.3.0

data/test/vagrant/actions/vm/provision_test.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class ProvisionActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Provision)
-    mock_config
   end
 
   context "initialization" do
@@ -29,9 +28,7 @@ class ProvisionActionTest < Test::Unit::TestCase
   context "preparing" do
     context "with a nil provisioner" do
       setup do
-        mock_config do |config|
-          config.vm.provisioner = nil
-        end
+        @runner.env.config.vm.provisioner = nil
       end
 
       should "not set a provisioner if set to nil" do
@@ -47,15 +44,13 @@ class ProvisionActionTest < Test::Unit::TestCase
         @instance.stubs(:prepare)
         @klass = mock("klass")
         @klass.stubs(:is_a?).with(Class).returns(true)
-        @klass.stubs(:new).returns(@instance)
+        @klass.stubs(:new).with(@runner.env).returns(@instance)
 
-        mock_config do |config|
-          config.vm.provisioner = @klass
-        end
+        @runner.env.config.vm.provisioner = @klass
       end
 
       should "set the provisioner to an instantiation of the class" do
-        @klass.expects(:new).once.returns(@instance)
+        @klass.expects(:new).with(@runner.env).once.returns(@instance)
         assert_nothing_raised { @action.prepare }
         assert_equal @instance, @action.provisioner
       end
@@ -75,21 +70,17 @@ class ProvisionActionTest < Test::Unit::TestCase
 
     context "with a Symbol provisioner" do
       def provisioner_expectation(symbol, provisioner)
-        mock_config do |config|
-          config.vm.provisioner = symbol
-        end
+        @runner.env.config.vm.provisioner = symbol
 
         instance = mock("instance")
         instance.expects(:prepare).once
-        provisioner.expects(:new).returns(instance)
+        provisioner.expects(:new).with(@runner.env).returns(instance)
         assert_nothing_raised { @action.prepare }
         assert_equal instance, @action.provisioner
       end
 
       should "raise an ActionException if its an unknown symbol" do
-        mock_config do |config|
-          config.vm.provisioner = :this_will_never_exist
-        end
+        @runner.env.config.vm.provisioner = :this_will_never_exist
 
         assert_raises(Vagrant::Actions::ActionException) {
           @action.prepare

data/test/vagrant/actions/vm/reload_test.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class ReloadActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Reload)
-    mock_config
   end
 
   context "sub-actions" do
@@ -32,11 +31,13 @@ class ReloadActionTest < Test::Unit::TestCase
     end
 
     should "add in the provisioning step if enabled" do
-      mock_config do |config|
+      env = mock_environment do |config|
         # Dummy provisioner to test
         config.vm.provisioner = "foo"
       end
 
+      @runner.stubs(:env).returns(env)
+
       @default_order.push(Vagrant::Actions::VM::Provision)
       setup_action_expectations
       @action.prepare

data/test/vagrant/actions/vm/resume_test.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class ResumeActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Resume)
-    mock_config
   end
 
   context "executing" do

data/test/vagrant/actions/vm/shared_folders_test.rb

@@ -2,8 +2,7 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class SharedFoldersActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::SharedFolders)
-    mock_config
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::SharedFolders)
   end
 
   def stub_shared_folders
@@ -27,11 +26,13 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     end
 
     should "convert the vagrant config values into an array" do
-      mock_config do |config|
+      env = mock_environment do |config|
         config.vm.shared_folders.clear
         config.vm.share_folder("foo", "bar", "baz")
       end
 
+      @runner.expects(:env).returns(env)
+
       result = [["foo", "baz", "bar"]]
       assert_equal result, @action.shared_folders
     end
@@ -39,11 +40,13 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     should "expand the path of the host folder" do
       File.expects(:expand_path).with("baz").once.returns("expanded_baz")
 
-      mock_config do |config|
+      env = mock_environment do |config|
         config.vm.shared_folders.clear
         config.vm.share_folder("foo", "bar", "baz")
       end
 
+      @runner.expects(:env).returns(env)
+
       result = [["foo", "expanded_baz", "bar"]]
       assert_equal result, @action.shared_folders
     end
@@ -62,7 +65,7 @@ class SharedFoldersActionTest < Test::Unit::TestCase
         sf.expects(:destroy).once.in_sequence(destroy_seq)
       end
 
-      @mock_vm.expects(:reload!).once.in_sequence(destroy_seq)
+      @runner.expects(:reload!).once.in_sequence(destroy_seq)
       @action.clear_shared_folders
     end
   end
@@ -75,10 +78,10 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     should "add all shared folders to the VM" do
       share_seq = sequence("share_seq")
       shared_folders = mock("shared_folders")
-      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "foo" && sf.hostpath == "from" }
-      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "bar" && sf.hostpath == "bfrom" }
+      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "foo" && sf.host_path == "from" }
+      shared_folders.expects(:<<).in_sequence(share_seq).with() { |sf| sf.name == "bar" && sf.host_path == "bfrom" }
       @vm.stubs(:shared_folders).returns(shared_folders)
-      @vm.expects(:save).with(true).once
+      @vm.expects(:save).once
 
       @action.create_metadata
     end
@@ -95,9 +98,9 @@ class SharedFoldersActionTest < Test::Unit::TestCase
       @folders.each do |name, hostpath, guestpath|
         ssh.expects(:exec!).with("sudo mkdir -p #{guestpath}").in_sequence(mount_seq)
         @action.expects(:mount_folder).with(ssh, name, guestpath).in_sequence(mount_seq)
-        ssh.expects(:exec!).with("sudo chown #{Vagrant.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
+        ssh.expects(:exec!).with("sudo chown #{@runner.env.config.ssh.username} #{guestpath}").in_sequence(mount_seq)
       end
-      Vagrant::SSH.expects(:execute).yields(ssh)
+      @runner.env.ssh.expects(:execute).yields(ssh)
 
       @action.after_boot
     end
@@ -119,7 +122,7 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     end
 
     should "execute the proper mount command" do
-      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{Vagrant.config.ssh.username},gid=#{Vagrant.config.ssh.username} #{@name} #{@guestpath}").returns(@success_return)
+      @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{@runner.env.config.ssh.username},gid=#{@runner.env.config.ssh.username} #{@name} #{@guestpath}").returns(@success_return)
       mount_folder
     end
 
@@ -158,11 +161,13 @@ class SharedFoldersActionTest < Test::Unit::TestCase
     should "add uid AND gid to mount" do
       uid = "foo"
       gid = "bar"
-      mock_config do |config|
+      env = mock_environment do |config|
         config.vm.shared_folder_uid = uid
         config.vm.shared_folder_gid = gid
       end
 
+      @runner.expects(:env).twice.returns(env)
+
       @ssh.expects(:exec!).with("sudo mount -t vboxsf -o uid=#{uid},gid=#{gid} #{@name} #{@guestpath}").returns(@success_return)
       mount_folder
     end

data/test/vagrant/actions/vm/start_test.rb

@@ -3,19 +3,19 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class StartActionTest < Test::Unit::TestCase
   setup do
     @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Start)
-    mock_config
   end
 
   context "sub-actions" do
     setup do
+      @vm.stubs(:saved?).returns(true)
       File.stubs(:file?).returns(true)
       File.stubs(:exist?).returns(true)
-      @default_order = [Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+      @default_order = [Vagrant::Actions::VM::Boot]
     end
 
     def setup_action_expectations
       default_seq = sequence("default_seq")
-      @default_order.each do |action|
+      @default_order.flatten.each do |action|
         @mock_vm.expects(:add_action).with(action).once.in_sequence(default_seq)
       end
     end
@@ -24,5 +24,12 @@ class StartActionTest < Test::Unit::TestCase
       setup_action_expectations
       @action.prepare
     end
+
+    should "add customize to the beginning if its not saved" do
+      @vm.expects(:saved?).returns(false)
+      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders])
+      setup_action_expectations
+      @action.prepare
+    end
   end
 end

data/test/vagrant/actions/vm/suspend_test.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 class SuspendActionTest < Test::Unit::TestCase
   setup do
     @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Suspend)
-    mock_config
   end
 
   context "executing" do
@@ -12,7 +11,7 @@ class SuspendActionTest < Test::Unit::TestCase
     end
 
     should "save the state of the VM" do
-      @vm.expects(:save_state).with(true).once
+      @vm.expects(:save_state).once
       @action.execute!
     end
 

data/test/vagrant/actions/vm/up_test.rb

@@ -2,8 +2,7 @@ require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
 
 class UpActionTest < Test::Unit::TestCase
   setup do
-    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Up)
-    mock_config
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Up)
   end
 
   context "sub-actions" do
@@ -11,17 +10,20 @@ class UpActionTest < Test::Unit::TestCase
       File.stubs(:file?).returns(true)
       File.stubs(:exist?).returns(true)
       @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Boot]
+
+      @dotfile_path = "foo"
+      @runner.env.stubs(:dotfile_path).returns(@dotfile_path)
     end
 
     def setup_action_expectations
       default_seq = sequence("default_seq")
       @default_order.each do |action|
-        @mock_vm.expects(:add_action).with(action).once.in_sequence(default_seq)
+        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
       end
     end
 
     should "raise an ActionException if a dotfile exists but is not a file" do
-      File.expects(:file?).with(Vagrant::Env.dotfile_path).returns(false)
+      File.expects(:file?).with(@runner.env.dotfile_path).returns(false)
       assert_raises(Vagrant::Actions::ActionException) {
         @action.prepare
       }
@@ -46,21 +48,27 @@ class UpActionTest < Test::Unit::TestCase
     end
 
     should "add in the provisioning step if enabled" do
-      mock_config do |config|
+      env = mock_environment do |config|
         config.vm.provisioner = "foo"
       end
 
+      @runner.stubs(:env).returns(env)
+      env.stubs(:dotfile_path).returns(@dotfile_path)
+
       @default_order.push(Vagrant::Actions::VM::Provision)
       setup_action_expectations
       @action.prepare
     end
 
     should "add in the action to move hard drive if config is set" do
-      mock_config do |config|
+      env = mock_environment do |config|
         File.expects(:directory?).with("foo").returns(true)
         config.vm.hd_location = "foo"
       end
 
+      @runner.stubs(:env).returns(env)
+      env.stubs(:dotfile_path).returns(@dotfile_path)
+
       @default_order.insert(0, Vagrant::Actions::VM::MoveHardDrive)
       setup_action_expectations
       @action.prepare
@@ -78,8 +86,8 @@ class UpActionTest < Test::Unit::TestCase
 
   context "persisting" do
     should "persist the VM with Env" do
-      @mock_vm.stubs(:uuid)
-      Vagrant::Env.expects(:persist_vm).with(@mock_vm).once
+      @runner.stubs(:uuid)
+      @runner.env.expects(:persist_vm).once
       @action.persist
     end
   end
@@ -87,10 +95,10 @@ class UpActionTest < Test::Unit::TestCase
   context "setting up MAC address" do
     should "match the mac address with the base" do
       nic = mock("nic")
-      nic.expects(:macaddress=).once
+      nic.expects(:mac_address=).once
 
-      @vm.expects(:nics).returns([nic]).once
-      @vm.expects(:save).with(true).once
+      @vm.expects(:network_adapters).returns([nic]).once
+      @vm.expects(:save).once
 
       @action.setup_mac_address
     end

data/test/vagrant/active_list_test.rb

@@ -2,168 +2,187 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class ActiveListTest < Test::Unit::TestCase
   setup do
-    mock_config
+    @env = mock_environment
+    @list = Vagrant::ActiveList.new(@env)
   end
 
-  context "class methods" do
-    context "loading" do
-      should "load if reload is given" do
-        File.stubs(:file?).returns(true)
-        File.expects(:open).once
-        Vagrant::ActiveList.list(true)
-      end
+  context "initializing" do
+    should "set the environment to nil if not specified" do
+      assert_nothing_raised {
+        list = Vagrant::ActiveList.new
+        assert list.env.nil?
+      }
+    end
 
-      should "not load if the active json file doesn't exist" do
-        File.expects(:file?).with(Vagrant::ActiveList.path).returns(false)
-        File.expects(:open).never
-        assert_equal [], Vagrant::ActiveList.list(true)
-      end
+    should "set the environment to the given parameter if specified" do
+      env = mock("env")
+      list = Vagrant::ActiveList.new(env)
+      assert_equal env, list.env
+    end
+  end
 
-      should "parse the JSON by reading the file" do
-        file = mock("file")
-        data = mock("data")
-        result = mock("result")
-        File.expects(:file?).returns(true)
-        File.expects(:open).with(Vagrant::ActiveList.path, 'r').once.yields(file)
-        file.expects(:read).returns(data)
-        JSON.expects(:parse).with(data).returns(result)
-        assert_equal result, Vagrant::ActiveList.list(true)
-      end
+  context "listing" do
+    setup do
+      @path = "foo"
+      @list.stubs(:path).returns(@path)
+    end
 
-      should "not load if reload flag is false and already loaded" do
-        File.expects(:file?).once.returns(false)
-        result = Vagrant::ActiveList.list(true)
-        assert result.equal?(Vagrant::ActiveList.list)
-        assert result.equal?(Vagrant::ActiveList.list)
-        assert result.equal?(Vagrant::ActiveList.list)
-      end
+    should "load if reload is given" do
+      File.stubs(:file?).returns(true)
+      File.expects(:open).once
+      @list.list(true)
     end
 
-    context "vms" do
-      setup do
-        @list = ["foo", "bar"]
-        Vagrant::ActiveList.stubs(:list).returns(@list)
-      end
+    should "not load if the active json file doesn't exist" do
+      File.expects(:file?).with(@list.path).returns(false)
+      File.expects(:open).never
+      assert_equal [], @list.list(true)
+    end
+
+    should "parse the JSON by reading the file" do
+      file = mock("file")
+      data = mock("data")
+      result = mock("result")
+      File.expects(:file?).returns(true)
+      File.expects(:open).with(@list.path, 'r').once.yields(file)
+      file.expects(:read).returns(data)
+      JSON.expects(:parse).with(data).returns(result)
+      assert_equal result, @list.list(true)
+    end
+
+    should "not load if reload flag is false and already loaded" do
+      File.expects(:file?).once.returns(false)
+      result = @list.list(true)
+      assert result.equal?(@list.list)
+      assert result.equal?(@list.list)
+      assert result.equal?(@list.list)
+    end
+  end
 
-      should "return the list, but with each value as a VM" do
-        new_seq = sequence("new")
-        results = []
-        @list.each do |item|
-          result = mock("result-#{item}")
-          Vagrant::VM.expects(:find).with(item).returns(result).in_sequence(new_seq)
-          results << result
-        end
+  context "vms" do
+    setup do
+      @the_list = ["foo", "bar"]
+      @list.stubs(:list).returns(@the_list)
+    end
 
-        assert_equal results, Vagrant::ActiveList.vms
+    should "return the list, but with each value as a VM" do
+      new_seq = sequence("new")
+      results = []
+      @the_list.each do |item|
+        result = mock("result-#{item}")
+        Vagrant::VM.expects(:find).with(item).returns(result).in_sequence(new_seq)
+        results << result
       end
 
-      should "compact out the nil values" do
-        Vagrant::VM.stubs(:find).returns(nil)
-        results = Vagrant::ActiveList.vms
-        assert results.empty?
-      end
+      assert_equal results, @list.vms
     end
 
-    context "filtered list" do
-      should "return a list of UUIDs from the VMs" do
-        vms = []
-        result = []
-        5.times do |i|
-          vm = mock("vm#{i}")
-          vm.expects(:uuid).returns(i)
-          result << i
-          vms << vm
-        end
+    should "compact out the nil values" do
+      Vagrant::VM.stubs(:find).returns(nil)
+      results = @list.vms
+      assert results.empty?
+    end
+  end
 
-        Vagrant::ActiveList.stubs(:vms).returns(vms)
-        assert_equal result, Vagrant::ActiveList.filtered_list
+  context "filtered list" do
+    should "return a list of UUIDs from the VMs" do
+      vms = []
+      result = []
+      5.times do |i|
+        vm = mock("vm#{i}")
+        vm.expects(:uuid).returns(i)
+        result << i
+        vms << vm
       end
+
+      @list.stubs(:vms).returns(vms)
+      assert_equal result, @list.filtered_list
     end
+  end
 
-    context "adding a VM to the list" do
-      setup do
-        @list = []
-        Vagrant::ActiveList.stubs(:list).returns(@list)
-        Vagrant::ActiveList.stubs(:save)
+  context "adding a VM to the list" do
+    setup do
+      @the_list = []
+      @list.stubs(:list).returns(@the_list)
+      @list.stubs(:save)
 
-        @uuid = "foo"
-        @vm = mock("vm")
-        @vm.stubs(:uuid).returns(@uuid)
-      end
+      @uuid = "foo"
+      @vm = mock("vm")
+      @vm.stubs(:uuid).returns(@uuid)
+    end
 
-      should "add the VMs UUID to the list" do
-        Vagrant::ActiveList.add(@vm)
-        assert_equal [@uuid], @list
-      end
+    should "add the VMs UUID to the list" do
+      @list.add(@vm)
+      assert_equal [@uuid], @the_list
+    end
 
-      should "uniq the array so multiples never exist" do
-        @list << @uuid
-        assert_equal 1, @list.length
-        Vagrant::ActiveList.add(@vm)
-        assert_equal 1, @list.length
-      end
+    should "uniq the array so multiples never exist" do
+      @the_list << @uuid
+      assert_equal 1, @the_list.length
+      @list.add(@vm)
+      assert_equal 1, @the_list.length
+    end
 
-      should "save after adding" do
-        save_seq = sequence('save')
-        @list.expects(:<<).in_sequence(save_seq)
-        Vagrant::ActiveList.expects(:save).in_sequence(save_seq)
-        Vagrant::ActiveList.add(@vm)
-      end
+    should "save after adding" do
+      save_seq = sequence('save')
+      @the_list.expects(:<<).in_sequence(save_seq)
+      @list.expects(:save).in_sequence(save_seq)
+      @list.add(@vm)
     end
+  end
 
-    context "deleting a VM from the list" do
-      setup do
-        @list = ["bar"]
-        Vagrant::ActiveList.stubs(:list).returns(@list)
-        Vagrant::ActiveList.stubs(:save)
+  context "deleting a VM from the list" do
+    setup do
+      @the_list = ["bar"]
+      @list.stubs(:list).returns(@the_list)
+      @list.stubs(:save)
 
-        @uuid = "bar"
-        @vm = mock("vm")
-        @vm.stubs(:uuid).returns(@uuid)
-        @vm.stubs(:is_a?).with(Vagrant::VM).returns(true)
-      end
+      @uuid = "bar"
+      @vm = mock("vm")
+      @vm.stubs(:uuid).returns(@uuid)
+      @vm.stubs(:is_a?).with(Vagrant::VM).returns(true)
+    end
 
-      should "delete the uuid from the list of a VM" do
-        Vagrant::ActiveList.remove(@vm)
-        assert @list.empty?
-      end
+    should "delete the uuid from the list of a VM" do
+      @list.remove(@vm)
+      assert @the_list.empty?
+    end
 
-      should "delete just the string if a string is given" do
-        @list << "zoo"
-        Vagrant::ActiveList.remove("zoo")
-        assert !@list.include?("zoo")
-      end
+    should "delete just the string if a string is given" do
+      @the_list << "zoo"
+      @list.remove("zoo")
+      assert !@the_list.include?("zoo")
+    end
 
-      should "save after removing" do
-        save_seq = sequence('save')
-        @list.expects(:delete).in_sequence(save_seq)
-        Vagrant::ActiveList.expects(:save).in_sequence(save_seq)
-        Vagrant::ActiveList.remove(@vm)
-      end
+    should "save after removing" do
+      save_seq = sequence('save')
+      @the_list.expects(:delete).in_sequence(save_seq)
+      @list.expects(:save).in_sequence(save_seq)
+      @list.remove(@vm)
     end
+  end
 
-    context "saving" do
-      setup do
-        @filtered = ["zoo"]
-        Vagrant::ActiveList.stubs(:filtered_list).returns(@filtered)
-      end
+  context "saving" do
+    setup do
+      @filtered = ["zoo"]
+      @list.stubs(:filtered_list).returns(@filtered)
+    end
 
-      should "open the JSON path and save to it" do
-        file = mock("file")
-        File.expects(:open).with(Vagrant::ActiveList.path, "w+").yields(file)
-        file.expects(:write).with(@filtered.to_json)
-        Vagrant::ActiveList.save
-      end
+    should "open the JSON path and save to it" do
+      file = mock("file")
+      File.expects(:open).with(@list.path, "w+").yields(file)
+      file.expects(:write).with(@filtered.to_json)
+      @list.save
     end
+  end
 
-    context "path" do
-      setup do
-        Vagrant::Env.stubs(:home_path).returns("foo")
-      end
+  context "path" do
+    setup do
+      @env.stubs(:home_path).returns("foo")
+    end
 
-      should "return the active file within the home path" do
-        assert_equal File.join(Vagrant::Env.home_path, Vagrant::ActiveList::FILENAME), Vagrant::ActiveList.path
-      end
+    should "return the active file within the home path" do
+      assert_equal File.join(@env.home_path, Vagrant::ActiveList::FILENAME), @list.path
     end
   end
 end