bmabey-vagrant 0.2.0

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

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class BootActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Boot)
+    @runner.stubs(:invoke_callback)
+    mock_config
+  end
+
+  context "preparing" do
+    should "add the root shared folder" do
+      @runner.env.config.vm.expects(:share_folder).with("vagrant-root", @runner.env.config.vm.project_directory, @runner.env.root_path).once
+      @action.prepare
+    end
+  end
+
+  context "execution" do
+    should "invoke the 'boot' around callback" do
+      boot_seq = sequence("boot_seq")
+      @runner.expects(:invoke_around_callback).with(:boot).once.in_sequence(boot_seq).yields
+      @action.expects(:boot).in_sequence(boot_seq)
+      @action.expects(:wait_for_boot).returns(true).in_sequence(boot_seq)
+      @action.execute!
+    end
+
+    should "error and exit if the bootup failed" do
+      fail_boot_seq = sequence("fail_boot_seq")
+      @action.expects(:boot).once.in_sequence(fail_boot_seq)
+      @action.expects(:wait_for_boot).returns(false).in_sequence(fail_boot_seq)
+      @action.expects(:error_and_exit).with(:vm_failed_to_boot).once.in_sequence(fail_boot_seq)
+      @action.execute!
+    end
+  end
+
+  context "booting" do
+    should "start the VM in headless mode" do
+      @vm.expects(:start).with(:headless, true).once
+      @action.boot
+    end
+  end
+
+  context "waiting for boot" do
+    should "repeatedly ping the SSH port and return false with no response" do
+      seq = sequence('pings')
+      @runner.env.ssh.expects(:up?).times(@runner.env.config.ssh.max_tries.to_i - 1).returns(false).in_sequence(seq)
+      @runner.env.ssh.expects(:up?).once.returns(true).in_sequence(seq)
+      assert @action.wait_for_boot(0)
+    end
+
+    should "ping the max number of times then just return" do
+      @runner.env.ssh.expects(:up?).times(Vagrant.config.ssh.max_tries.to_i).returns(false)
+      assert !@action.wait_for_boot(0)
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class CustomizeActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Customize)
+    mock_config
+  end
+
+  context "executing" do
+    should "run the VM customization procs then save the VM" do
+      @runner.env.config.vm.expects(:run_procs!).with(@vm)
+      @vm.expects(:save).with(true).once
+      @action.execute!
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class DestroyActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
+  end
+
+  context "executing" do
+    should "invoke an around callback around the destroy" do
+      @runner.expects(:invoke_around_callback).with(:destroy).once
+      @action.execute!
+    end
+
+    should "destroy VM and clear persist" do
+      @runner.stubs(:invoke_around_callback).yields
+      clear_seq = sequence("clear")
+      @action.expects(:destroy_vm).in_sequence(clear_seq)
+      @action.expects(:depersist).in_sequence(clear_seq)
+      @action.execute!
+    end
+  end
+
+  context "destroying the VM" do
+    should "destroy VM and attached images" do
+      @vm.expects(:destroy).with(:destroy_image => true).once
+      @action.destroy_vm
+    end
+  end
+
+  context "depersisting" do
+    should "call depersist_vm on Env" do
+      @runner.env.expects(:depersist_vm).once
+      @action.depersist
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class DownActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Down)
+    mock_config
+  end
+
+  context "preparing" do
+    setup do
+      @vm.stubs(:running?).returns(false)
+    end
+
+    def setup_action_expectations(order)
+      default_seq = sequence("default_seq")
+      order.each do |action|
+        @mock_vm.expects(:add_action).with(action).once.in_sequence(default_seq)
+      end
+    end
+
+    should "add the destroy action alone if VM is not running" do
+      setup_action_expectations([Vagrant::Actions::VM::Destroy])
+      @action.prepare
+    end
+
+    should "add the halt action if the VM is running" do
+      @vm.expects(:running?).returns(true)
+      setup_action_expectations([Vagrant::Actions::VM::Halt, Vagrant::Actions::VM::Destroy])
+      @action.prepare
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ExportActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Export)
+    mock_config
+  end
+
+  context "executing" do
+    should "setup the temp dir then export" do
+      exec_seq = sequence('execute')
+      @action.expects(:setup_temp_dir).once.in_sequence(exec_seq)
+      @action.expects(:export).once.in_sequence(exec_seq)
+      @action.execute!
+    end
+  end
+
+  context "setting up the temporary directory" do
+    setup do
+      @time_now = Time.now.to_i.to_s
+      Time.stubs(:now).returns(@time_now)
+
+      @tmp_path = "foo"
+      @runner.env.stubs(:tmp_path).returns(@tmp_path)
+
+      @temp_dir = File.join(@runner.env.tmp_path, @time_now)
+      FileUtils.stubs(:mkpath)
+    end
+
+    should "create the temporary directory using the current time" do
+      FileUtils.expects(:mkpath).with(@temp_dir).once
+      @action.setup_temp_dir
+    end
+
+    should "set the temporary directory to the temp_dir variable" do
+      @action.setup_temp_dir
+      assert_equal @temp_dir, @action.temp_dir
+    end
+  end
+
+  context "path to OVF file" do
+    setup do
+      @temp_dir = "foo"
+      @action.stubs(:temp_dir).returns(@temp_dir)
+    end
+
+    should "be the temporary directory joined with the OVF filename" do
+      assert_equal File.join(@temp_dir, @runner.env.config.vm.box_ovf), @action.ovf_path
+    end
+  end
+
+  context "exporting" do
+    setup do
+      @ovf_path = mock("ovf_path")
+      @action.stubs(:ovf_path).returns(@ovf_path)
+    end
+
+    should "call export on the runner with the ovf path" do
+      @vm.expects(:export).with(@ovf_path, {}, true).once
+      @action.export
+    end
+  end
+
+  context "cleanup" do
+    setup do
+      @temp_dir = "foo"
+      @action.stubs(:temp_dir).returns(@temp_dir)
+    end
+
+    should "remove the temporary directory" do
+      FileUtils.expects(:rm_r).with(@temp_dir).once
+      @action.cleanup
+    end
+
+    should "not remove a directory if temp_dir is nil" do
+      FileUtils.expects(:rm_r).never
+      @action.stubs(:temp_dir).returns(nil)
+      @action.cleanup
+    end
+  end
+
+  context "rescue" do
+    should "call cleanup method" do
+      @action.expects(:cleanup).once
+      @action.rescue(nil)
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ForwardPortsActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::ForwardPorts)
+    mock_config
+  end
+
+  context "checking for colliding ports" do
+    setup do
+      @forwarded_port = mock("forwarded_port")
+      @forwarded_port.stubs(:hostport)
+      @forwarded_ports = [@forwarded_port]
+
+      @vm = mock("vm")
+      @vm.stubs(:forwarded_ports).returns(@forwarded_ports)
+      @vm.stubs(:running?).returns(true)
+      @vm.stubs(:uuid).returns("foo")
+      @mock_vm.stubs(:uuid).returns("bar")
+      vms = [@vm]
+      VirtualBox::VM.stubs(:all).returns(vms)
+
+      @env = mock_environment do |config|
+        config.vm.forwarded_ports.clear
+        config.vm.forward_port("ssh", 22, 2222)
+      end
+
+      @mock_vm.stubs(:env).returns(@env)
+    end
+
+    should "ignore vms which aren't running" do
+      @vm.expects(:running?).returns(false)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "ignore vms which are equivalent to ours" do
+      @mock_vm.expects(:uuid).returns(@vm.uuid)
+      @vm.expects(:forwarded_ports).never
+      @action.prepare
+    end
+
+    should "not raise any errors if no forwarded ports collide" do
+      @forwarded_port.expects(:hostport).returns(80)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an ActionException if a port collides" do
+      @forwarded_port.expects(:hostport).returns(2222)
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "convert ports to strings prior to checking" do
+      @forwarded_port.expects(:hostport).returns("2222")
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+  end
+
+  context "execution" do
+    should "clear all previous ports and forward new ports" do
+      exec_seq = sequence("exec_seq")
+      @action.expects(:clear).once.in_sequence(exec_seq)
+      @action.expects(:forward_ports).once.in_sequence(exec_seq)
+      @action.execute!
+    end
+  end
+
+  context "forwarding ports" do
+    should "create a port forwarding for the VM" do
+      forwarded_ports = mock("forwarded_ports")
+
+      @mock_vm.env.config.vm.forwarded_ports.each do |name, opts|
+        forwarded_ports.expects(:<<).with do |port|
+          assert_equal name, port.name
+          assert_equal opts[:hostport], port.hostport
+          assert_equal opts[:guestport], port.guestport
+          true
+        end
+      end
+
+      @vm.expects(:forwarded_ports).returns(forwarded_ports)
+      @vm.expects(:save).with(true).once
+      @action.forward_ports
+    end
+  end
+
+  context "clearing forwarded ports" do
+    should "call destroy on all forwarded ports" do
+      forwarded_ports = []
+      5.times do |i|
+        port = mock("port#{i}")
+        port.expects(:destroy).with(true).once
+        forwarded_ports << port
+      end
+
+      @vm.expects(:forwarded_ports).returns(forwarded_ports)
+      @action.clear
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class HaltActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Halt)
+    mock_config
+  end
+
+  context "executing" do
+    setup do
+      @vm.stubs(:running?).returns(true)
+    end
+
+    should "force the VM to stop" do
+      @vm.expects(:stop).with(true).once
+      @action.execute!
+    end
+
+    should "raise an ActionException if VM is not running" do
+      @vm.stubs(:running?).returns(false)
+      @vm.expects(:stop).never
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.execute!
+      }
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ImportActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @import = mock_action(Vagrant::Actions::VM::Import)
+
+    @ovf_file = "foo"
+    @box = mock("box")
+    @box.stubs(:ovf_file).returns(@ovf_file)
+    @runner.env.stubs(:box).returns(@box)
+
+    VirtualBox::VM.stubs(:import)
+  end
+
+  should "run in a busy block" do
+    Vagrant::Busy.expects(:busy).once
+    @import.execute!
+  end
+
+  should "invoke an around callback around the import" do
+    @runner.expects(:invoke_around_callback).with(:import).once
+    @import.execute!
+  end
+
+  should "call import on VirtualBox::VM with the proper base" do
+    VirtualBox::VM.expects(:import).once.with(@ovf_file).returns("foo")
+    assert_nothing_raised { @import.execute! }
+  end
+
+  should "raise an exception if import is nil" do
+    @runner.expects(:vm).returns(nil)
+    assert_raises(Vagrant::Actions::ActionException) {
+      @import.execute!
+    }
+  end
+
+  should "set the resulting VM as the VM of the Vagrant VM object" do
+    new_vm = mock("new_vm")
+    @runner.expects(:vm=).with(new_vm).once
+    VirtualBox::VM.expects(:import).returns(new_vm).returns("foo")
+    @import.execute!
+  end
+end

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

@@ -0,0 +1,108 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class MoveHardDriveActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::MoveHardDrive)
+    @hd_location = "/foo"
+    mock_config do |config|
+      File.expects(:directory?).with(@hd_location).returns(true)
+      config.vm.hd_location = @hd_location
+    end
+  end
+
+
+  should "be able to identifiy a hard drive within the storage controllers" do
+    hd = mock('hd')
+    hd_image = mock('hd_image')
+    hd_image.expects(:is_a?).returns(true)
+    hd.expects(:image).returns(hd_image)
+
+    dvd = mock('dvd')
+    controller = mock('controller')
+    controller.expects(:devices).returns([hd, dvd])
+
+    @vm.expects(:storage_controllers).once.returns([controller])
+    assert_equal @action.find_hard_drive, hd
+  end
+
+  context "execution" do
+    should "error and exit if the vm is not powered off" do
+      @mock_vm.expects(:powered_off?).returns(false)
+      @action.expects(:error_and_exit).with(:vm_power_off_to_move_hd).once
+      @action.execute!
+    end
+
+    should "move the hard drive if vm is powered off" do
+      @mock_vm.expects(:powered_off?).returns(true)
+      @action.expects(:error_and_exit).never
+      @action.expects(:destroy_drive_after).once
+      @action.execute!
+    end
+  end
+
+  context "new image path" do
+    setup do
+      @hd = mock("hd")
+      @image = mock("image")
+      @filename = "foo"
+      @hd.stubs(:image).returns(@image)
+      @image.stubs(:filename).returns(@filename)
+      @action.stubs(:hard_drive).returns(@hd)
+    end
+
+    should "be the configured hd location and the existing hard drive filename" do
+      joined = File.join(Vagrant.config.vm.hd_location, @filename)
+      assert_equal joined, @action.new_image_path
+    end
+  end
+
+  context "cloning and attaching new image" do
+    setup do
+      @hd = mock("hd")
+      @image = mock("image")
+      @hd.stubs(:image).returns(@image)
+      @action.stubs(:hard_drive).returns(@hd)
+      @new_image_path = "foo"
+      @action.stubs(:new_image_path).returns(@new_image_path)
+    end
+
+    should "clone to the new path" do
+      new_image = mock("new_image")
+      @image.expects(:clone).with(@new_image_path, Vagrant.config.vm.disk_image_format, true).returns(new_image).once
+      @hd.expects(:image=).with(new_image).once
+      @vm.expects(:save).once
+      @action.clone_and_attach
+    end
+  end
+
+  context "destroying the old image" do
+    setup do
+      @hd = mock("hd")
+      @action.stubs(:hard_drive).returns(@hd)
+    end
+
+    should "yield the block, and destroy the old image after" do
+      image = mock("image")
+      image.stubs(:filename).returns("foo")
+      destroy_seq = sequence("destroy_seq")
+      @hd.expects(:image).returns(image).in_sequence(destroy_seq)
+      @hd.expects(:foo).once.in_sequence(destroy_seq)
+      image.expects(:destroy).with(true).once.in_sequence(destroy_seq)
+
+      @action.destroy_drive_after { @hd.foo }
+    end
+
+    # Ensures that the image is not destroyed in an "ensure" block
+    should "not destroy the image if an exception is raised" do
+      image = mock("image")
+      image.expects(:destroy).never
+      @hd.expects(:image).returns(image)
+
+      assert_raises(Exception) do
+        @action.destroy_drive_after do
+          raise Exception.new("FOO")
+        end
+      end
+    end
+  end
+end