vagrantup 0.3.4 → 0.4.0

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

@@ -2,11 +2,14 @@ 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)
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Start)
+
+    @action.options[:provision] = true
   end
 
   context "sub-actions" do
     setup do
+      @runner.stubs(:created?).returns(false)
       @vm.stubs(:saved?).returns(true)
       File.stubs(:file?).returns(true)
       File.stubs(:exist?).returns(true)
@@ -16,7 +19,7 @@ class StartActionTest < Test::Unit::TestCase
     def setup_action_expectations
       default_seq = sequence("default_seq")
       @default_order.flatten.each do |action|
-        @mock_vm.expects(:add_action).with(action).once.in_sequence(default_seq)
+        @runner.expects(:add_action).with(action, @action.options).once.in_sequence(default_seq)
       end
     end
 
@@ -27,9 +30,44 @@ class StartActionTest < Test::Unit::TestCase
 
     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])
+      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
+      setup_action_expectations
+      @action.prepare
+    end
+
+    should "add do additional if VM is not created yet" do
+      @runner.stubs(:vm).returns(nil)
+      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
       setup_action_expectations
       @action.prepare
     end
+
+    should "add provisioning if its enabled and not saved" do
+      @vm.env.config.vm.provisioner = :chef_solo
+
+      @runner.stubs(:vm).returns(nil)
+      @default_order.unshift([Vagrant::Actions::VM::Customize, Vagrant::Actions::VM::ForwardPorts, Vagrant::Actions::VM::SharedFolders, Vagrant::Actions::VM::Network])
+      @default_order << Vagrant::Actions::VM::Provision
+      setup_action_expectations
+      @action.prepare
+    end
+  end
+
+  context "provision?" do
+    should "return false if no provisioner is set" do
+      @vm.env.config.vm.provisioner = nil
+      assert !@action.provision?
+    end
+
+    should "return true if a provisioner is set" do
+      @vm.env.config.vm.provisioner = :chef_solo
+      assert @action.provision?
+    end
+
+    should "return false if provisioning is specifically disabled" do
+      @vm.env.config.vm.provisioner = :chef_solo
+      @action.options[:provision] = false
+      assert !@action.provision?
+    end
   end
 end

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

@@ -7,9 +7,11 @@ class UpActionTest < Test::Unit::TestCase
 
   context "sub-actions" do
     setup do
+      @runner.stubs(:created?).returns(false)
+
       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]
+      @default_order = [Vagrant::Actions::VM::Import, Vagrant::Actions::VM::Start]
 
       @dotfile_path = "foo"
       @runner.env.stubs(:dotfile_path).returns(@dotfile_path)
@@ -18,7 +20,7 @@ class UpActionTest < Test::Unit::TestCase
     def setup_action_expectations
       default_seq = sequence("default_seq")
       @default_order.each do |action|
-        @runner.expects(:add_action).with(action).once.in_sequence(default_seq)
+        @runner.expects(:add_action).with(action, @action.options).once.in_sequence(default_seq)
       end
     end
 
@@ -47,19 +49,6 @@ class UpActionTest < Test::Unit::TestCase
       @action.prepare
     end
 
-    should "add in the provisioning step if enabled" do
-      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
       env = mock_environment do |config|
         File.expects(:directory?).with("foo").returns(true)
@@ -76,19 +65,19 @@ class UpActionTest < Test::Unit::TestCase
   end
 
   context "callbacks" do
-    should "call persist and mac address setup after import" do
+    should "call update dotfile and mac address setup after import" do
       boot_seq = sequence("boot")
-      @action.expects(:persist).once.in_sequence(boot_seq)
+      @action.expects(:update_dotfile).once.in_sequence(boot_seq)
       @action.expects(:setup_mac_address).once.in_sequence(boot_seq)
       @action.after_import
     end
   end
 
-  context "persisting" do
-    should "persist the VM with Env" do
+  context "updating the dotfile" do
+    should "call update dotfile on the VM's environment" do
       @runner.stubs(:uuid)
-      @runner.env.expects(:persist_vm).once
-      @action.persist
+      @runner.env.expects(:update_dotfile).once
+      @action.update_dotfile
     end
   end
 

data/test/vagrant/active_list_test.rb

@@ -36,13 +36,13 @@ class ActiveListTest < Test::Unit::TestCase
     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)
+      assert_equal Hash.new, @list.list(true)
     end
 
     should "parse the JSON by reading the file" do
       file = mock("file")
       data = mock("data")
-      result = mock("result")
+      result = { :hey => :yep }
       File.expects(:file?).returns(true)
       File.expects(:open).with(@list.path, 'r').once.yields(file)
       file.expects(:read).returns(data)
@@ -57,52 +57,43 @@ class ActiveListTest < Test::Unit::TestCase
       assert result.equal?(@list.list)
       assert result.equal?(@list.list)
     end
-  end
 
-  context "vms" do
-    setup do
-      @the_list = ["foo", "bar"]
-      @list.stubs(:list).returns(@the_list)
-    end
+    should "be an empty hash if JSON parsing raises an exception" do
+      file = mock("file")
+      file.stubs(:read)
+      File.expects(:file?).returns(true)
+      File.expects(:open).with(@list.path, 'r').once.yields(file)
+      JSON.expects(:parse).raises(Exception)
 
-    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
+      assert_nothing_raised do
+        assert_equal Hash.new, @list.list(true)
       end
-
-      assert_equal results, @list.vms
-    end
-
-    should "compact out the nil values" do
-      Vagrant::VM.stubs(:find).returns(nil)
-      results = @list.vms
-      assert results.empty?
     end
   end
 
-  context "filtered list" do
-    should "return a list of UUIDs from the VMs" do
-      vms = []
-      result = []
+  context "filter list" do
+    should "remove nonexistent VMs" do
+      list = {}
+      result = {}
       5.times do |i|
         vm = mock("vm#{i}")
-        vm.expects(:uuid).returns(i)
-        result << i
-        vms << vm
+        vm.stubs(:uuid).returns(i)
+
+        list[vm.uuid] = {}
+
+        found_vm = i % 2 ? nil : vm
+        Vagrant::VM.stubs(:find).with(vm.uuid, @env).returns(found_vm)
+        results[vm.uuid] = {} if found_vm
       end
 
-      @list.stubs(:vms).returns(vms)
-      assert_equal result, @list.filtered_list
+      @list.stubs(:list).returns(list)
+      assert_equal result, @list.filter_list
     end
   end
 
   context "adding a VM to the list" do
     setup do
-      @the_list = []
+      @the_list = {}
       @list.stubs(:list).returns(@the_list)
       @list.stubs(:save)
 
@@ -113,19 +104,13 @@ class ActiveListTest < Test::Unit::TestCase
 
     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
-      @the_list << @uuid
-      assert_equal 1, @the_list.length
-      @list.add(@vm)
-      assert_equal 1, @the_list.length
+      assert @the_list[@uuid]
+      assert @the_list[@uuid].is_a?(Hash)
     end
 
     should "save after adding" do
       save_seq = sequence('save')
-      @the_list.expects(:<<).in_sequence(save_seq)
+      @the_list.expects(:[]=).in_sequence(save_seq)
       @list.expects(:save).in_sequence(save_seq)
       @list.add(@vm)
     end
@@ -165,7 +150,7 @@ class ActiveListTest < Test::Unit::TestCase
   context "saving" do
     setup do
       @filtered = ["zoo"]
-      @list.stubs(:filtered_list).returns(@filtered)
+      @list.stubs(:filter_list).returns(@filtered)
     end
 
     should "open the JSON path and save to it" do

data/test/vagrant/commands/base_test.rb

@@ -67,20 +67,40 @@ class CommandsBaseTest < Test::Unit::TestCase
     context "executing" do
       should "show version if flag is set" do
         @instance.expects(:puts_version).once
-        @instance.expects(:puts_help).never
+        @instance.expects(:show_help).never
         @instance.execute(["--version"])
       end
 
       should "just print the help by default" do
         @instance.expects(:puts_version).never
-        @klass.expects(:puts_help)
+        @instance.expects(:show_help).once
         @instance.execute([])
       end
     end
 
+    context "all or single methods" do
+      should "call the single method if a name is given" do
+        name = "bar"
+        @instance.expects(:foo_single).with(name).once
+        @instance.all_or_single(["bar"], :foo)
+      end
+
+      should "call the single method for each VM if no name is given" do
+        vms = { :foo => nil, :bar => nil }
+        vms.keys.each do |name|
+          @instance.expects(:foo_single).with(name).once
+        end
+
+        @env.stubs(:vms).returns(vms)
+        @instance.all_or_single([], :foo)
+      end
+    end
+
     context "getting the option parser" do
       should "create it with the options spec if it hasn't been created yet" do
         opts = mock("opts")
+        opts.stubs(:on)
+
         result = mock("result")
         OptionParser.expects(:new).yields(opts).returns(result)
         @instance.expects(:options_spec).with(opts)
@@ -110,8 +130,9 @@ class CommandsBaseTest < Test::Unit::TestCase
       end
 
       should "parse the options with the args" do
-        @option_parser.expects(:parse!).with(@args).once
-        assert_equal @options, @instance.parse_options(@args)
+        result = mock("result")
+        @option_parser.expects(:parse!).with(@args).once.returns(result)
+        assert_equal result, @instance.parse_options(@args)
       end
     end
   end

data/test/vagrant/commands/destroy_test.rb

@@ -4,29 +4,41 @@ class CommandsDestroyTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Destroy
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
 
     @instance = @klass.new(@env)
   end
 
   context "executing" do
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :destroy)
+      @instance.execute
+    end
+  end
+
+  context "destroying a single VM" do
     setup do
-      @persisted_vm.stubs(:destroy)
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
+    end
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.destroy_single(:foo)
     end
 
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
-      @instance.execute
+    should "destroy if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:destroy).once
+      @instance.destroy_single(:foo)
     end
 
-    should "destroy the persisted VM and the VM image" do
-      @persisted_vm.expects(:destroy).once
-      @instance.execute
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:destroy).never
+      @instance.destroy_single(:foo)
     end
   end
 end

data/test/vagrant/commands/halt_test.rb

@@ -4,25 +4,47 @@ class CommandsHaltTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Halt
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
-    should "require a persisted VM" do
-      @env.expects(:require_persisted_vm).once
+    should "call all or single for the method" do
+      @instance.expects(:all_or_single).with([], :halt)
       @instance.execute
     end
+  end
+
+  context "halting a single VM" do
+    setup do
+      @foo_vm = mock("vm")
+      @foo_vm.stubs(:env).returns(@env)
+      vms = { :foo => @foo_vm }
+      @env.stubs(:vms).returns(vms)
+    end
 
-    should "call the `halt` action on the VM" do
-      @persisted_vm.expects(:execute!).with(Vagrant::Actions::VM::Halt).once
-      @instance.execute
+    should "error and exit if the VM doesn't exist" do
+      @env.stubs(:vms).returns({})
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.halt_single(:foo)
+    end
+
+    should "halt if its created" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:halt).with(:force => false).once
+      @instance.execute(["foo"])
+    end
+
+    should "halt and force if specified" do
+      @foo_vm.stubs(:created?).returns(true)
+      @foo_vm.expects(:halt).with(:force => true).once
+      @instance.execute(["foo", "--force"])
+    end
+
+    should "do nothing if its not created" do
+      @foo_vm.stubs(:created?).returns(false)
+      @foo_vm.expects(:halt).never
+      @instance.halt_single(:foo)
     end
   end
 end

data/test/vagrant/commands/package_test.rb

@@ -4,81 +4,101 @@ class CommandsPackageTest < Test::Unit::TestCase
   setup do
     @klass = Vagrant::Commands::Package
 
-    @persisted_vm = mock("persisted_vm")
-    @persisted_vm.stubs(:execute!)
-
     @env = mock_environment
-    @env.stubs(:require_persisted_vm)
-    @env.stubs(:vm).returns(@persisted_vm)
-
     @instance = @klass.new(@env)
   end
 
   context "executing" do
+    should "package base if a base is given" do
+      @instance.expects(:package_base).once
+      @instance.execute(["--base","foo"])
+    end
+
+    should "package single if no name is given" do
+      @instance.expects(:package_single).with(nil).once
+      @instance.execute
+    end
+
+    should "package single if a name is given" do
+      @instance.expects(:package_single).with("foo").once
+      @instance.execute(["foo"])
+    end
+  end
+
+  context "packaging base" do
+    should "error and exit if no VM is found" do
+      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(nil)
+      @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => "foo").once
+      @instance.execute(["--base", "foo"])
+    end
+
+    should "package the VM like any other VM" do
+      vm = mock("vm")
+      Vagrant::VM.expects(:find).with("foo", @instance.env).returns(vm)
+      @instance.expects(:package_vm).with(vm).once
+      @instance.execute(["--base", "foo"])
+    end
+  end
+
+  context "packaging a single VM" do
     setup do
-      @persisted_vm.stubs(:package)
-      @persisted_vm.stubs(:powered_off?).returns(true)
+      @vm = mock("vm")
+      @vm.stubs(:created?).returns(true)
+
+      @vms = {:bar => @vm}
+      @env.stubs(:vms).returns(@vms)
+      @env.stubs(:multivm?).returns(false)
     end
 
-    context "with no base specified" do
-      should "require a persisted vm" do
-        @env.expects(:require_persisted_vm).once
-        @instance.execute
-      end
+    should "error and exit if no name is given in a multi-vm env" do
+      @env.stubs(:multivm?).returns(true)
+      @instance.expects(:error_and_exit).with(:package_multivm).once
+      @instance.package_single(nil)
     end
 
-    context "with base specified" do
-      setup do
-        @vm = mock("vm")
+    should "error and exit if the VM doesn't exist" do
+      @instance.expects(:error_and_exit).with(:unknown_vm, :vm => :foo).once
+      @instance.package_single(:foo)
+    end
 
-        Vagrant::VM.stubs(:find).with(@name).returns(@vm)
-        @vm.stubs(:env=).with(@env)
-        @env.stubs(:vm=)
+    should "error and exit if the VM is not created" do
+      @vm.stubs(:created?).returns(false)
+      @instance.expects(:error_and_exit).with(:environment_not_created).once
+      @instance.package_single(:bar)
+    end
 
-        @name = "bar"
-      end
+    should "use the first VM is no name is given in a single VM environment" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(nil)
+    end
 
-      should "find the given base and set it on the env" do
-        Vagrant::VM.expects(:find).with(@name).returns(@vm)
-        @vm.expects(:env=).with(@env)
-        @env.expects(:vm=).with(@vm)
+    should "package the VM" do
+      @instance.expects(:package_vm).with(@vm).once
+      @instance.package_single(:bar)
+    end
+  end
 
-        @instance.execute(["foo", "--base", @name])
-      end
+  context "packaging a VM" do
+    setup do
+      @vm = mock("vm")
+      @vm.stubs(:powered_off?).returns(true)
 
-      should "error if the VM is not found" do
-        Vagrant::VM.expects(:find).with(@name).returns(nil)
-        @instance.expects(:error_and_exit).with(:vm_base_not_found, :name => @name).once
+      @options = {}
+      @instance.stubs(:options).returns(@options)
+    end
 
-        @instance.execute(["foo", "--base", @name])
-      end
+    should "error and exit if VM is not powered off" do
+      @vm.stubs(:powered_off?).returns(false)
+      @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
+      @instance.package_vm(@vm)
     end
 
-    context "shared (with and without base specified)" do
-      should "error and exit if the VM is not powered off" do
-        @persisted_vm.stubs(:powered_off?).returns(false)
-        @instance.expects(:error_and_exit).with(:vm_power_off_to_package).once
-        @persisted_vm.expects(:package).never
-        @instance.execute
-      end
-
-      should "call package on the persisted VM" do
-        @persisted_vm.expects(:package).once
-        @instance.execute
-      end
-
-      should "pass the out path and include_files to the package method" do
-        out_path = mock("out_path")
-        include_files = "foo"
-        @persisted_vm.expects(:package).with(out_path, [include_files]).once
-        @instance.execute([out_path, "--include", include_files])
-      end
-
-      should "default to an empty array when not include_files are specified" do
-        out_path = mock("out_path")
-        @persisted_vm.expects(:package).with(out_path, []).once
-        @instance.execute([out_path])
-      end
+    should "package the VM with the proper arguments" do
+      @options[:output] = "foo.box"
+      @options[:include] = :bar
+
+      @vm.expects(:package).with(@options).once
+      @instance.package_vm(@vm)
     end
   end
 end