vagrant 0.1.0

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

@@ -0,0 +1,24 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class DestroyActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @action = mock_action(Vagrant::Actions::VM::Destroy)
+    mock_config
+  end
+
+  context "executing" do
+    setup do
+      @vm.stubs(:destroy)
+    end
+
+    should "invoke an around callback around the destroy" do
+      @mock_vm.expects(:invoke_around_callback).with(:destroy).once
+      @action.execute!
+    end
+
+    should "destroy VM and attached images" do
+      @vm.expects(:destroy).with(:destroy_image => true).once
+      @action.execute!
+    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"
+      Vagrant::Env.stubs(:tmp_path).returns(@tmp_path)
+
+      @temp_dir = File.join(Vagrant::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, Vagrant.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,50 @@
+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 "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")
+
+      Vagrant.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,36 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class ImportActionTest < Test::Unit::TestCase
+  setup do
+    @mock_vm, @vm, @import = mock_action(Vagrant::Actions::VM::Import)
+
+    @ovf_file = "foo"
+    @box = mock("box")
+    @box.stubs(:ovf_file).returns(@ovf_file)
+    Vagrant::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
+    @mock_vm.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)
+    @import.execute!
+  end
+
+  should "set the resulting VM as the VM of the Vagrant VM object" do
+    new_vm = mock("new_vm")
+    @mock_vm.expects(:vm=).with(new_vm).once
+    VirtualBox::VM.expects(:import).returns(new_vm)
+    @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).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

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

@@ -0,0 +1,155 @@
+require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
+
+class PackageActionTest < Test::Unit::TestCase
+  setup do
+    @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", [])
+
+    mock_config
+  end
+
+  context "initialization" do
+    def get_action(*args)
+      runner, vm, action = mock_action(Vagrant::Actions::VM::Package, *args)
+      return action
+    end
+
+    should "make out_path 'package' by default if nil is given" do
+      action = get_action(nil, [])
+      assert_equal "package", action.out_path
+    end
+
+    should "make include files an empty array by default" do
+      action = get_action("foo", nil)
+      assert action.include_files.is_a?(Array)
+      assert action.include_files.empty?
+    end
+  end
+
+  context "executing" do
+    setup do
+      @action.stubs(:compress)
+    end
+
+    should "compress" do
+      package_seq = sequence("package_seq")
+      @action.expects(:compress).in_sequence(package_seq)
+      @action.execute!
+    end
+  end
+
+  context "tar path" do
+    should "be the temporary directory with the name and extension attached" do
+      pwd = "foo"
+      FileUtils.stubs(:pwd).returns(pwd)
+      assert_equal File.join(pwd, "#{@action.out_path}#{Vagrant.config.package.extension}"), @action.tar_path
+    end
+  end
+
+  context "temp path" do
+    setup do
+      @export = mock("export")
+      @action.expects(:export_action).returns(@export)
+    end
+
+    should "use the export action's temp dir" do
+      path = mock("path")
+      @export.expects(:temp_dir).returns(path)
+      @action.temp_path
+    end
+  end
+
+  context "compression" do
+    setup do
+      @tar_path = "foo"
+      @action.stubs(:tar_path).returns(@tar_path)
+
+      @temp_path = "foo"
+      @action.stubs(:temp_path).returns(@temp_path)
+
+      @pwd = "bar"
+      FileUtils.stubs(:pwd).returns(@pwd)
+      FileUtils.stubs(:cd)
+
+      @tar = mock("tar")
+      Tar.stubs(:open).yields(@tar)
+    end
+
+    should "open the tar file with the tar path properly" do
+      Tar.expects(:open).with(@tar_path, File::CREAT | File::WRONLY, 0644, Tar::GNU).once
+      @action.compress
+    end
+
+    #----------------------------------------------------------------
+    # Methods below this comment test the block yielded by Tar.open
+    #----------------------------------------------------------------
+    should "cd to the directory and append the directory" do
+      compress_seq = sequence("compress_seq")
+      FileUtils.expects(:pwd).once.returns(@pwd).in_sequence(compress_seq)
+      FileUtils.expects(:cd).with(@temp_path).in_sequence(compress_seq)
+      @tar.expects(:append_tree).with(".").in_sequence(compress_seq)
+      FileUtils.expects(:cd).with(@pwd).in_sequence(compress_seq)
+      @action.compress
+    end
+
+    should "pop back to the current directory even if an exception is raised" do
+      cd_seq = sequence("cd_seq")
+      FileUtils.expects(:cd).with(@temp_path).raises(Exception).in_sequence(cd_seq)
+      FileUtils.expects(:cd).with(@pwd).in_sequence(cd_seq)
+
+      assert_raises(Exception) {
+        @action.compress
+      }
+    end
+
+    should "add included files when passed" do
+      include_files = ['foo', 'bar']
+      action = mock_action(Vagrant::Actions::VM::Package, "bing", include_files).last
+      action.stubs(:temp_path).returns("foo")
+      @tar.expects(:append_tree).with(".")
+      include_files.each { |f| @tar.expects(:append_file).with(f) }
+      action.compress
+    end
+
+    should "not add files when none are specified" do
+      @tar.expects(:append_tree).with(".")
+      @tar.expects(:append_file).never
+      @action.compress
+    end
+  end
+
+  context "preparing the action" do
+    context "checking include files" do
+      setup do
+        @include_files = ['fooiest', 'booiest']
+        @runner, @vm, @action = mock_action(Vagrant::Actions::VM::Package, "bing", @include_files)
+        @runner.stubs(:find_action).returns("foo")
+      end
+
+      should "check that all the include files exist" do
+        @include_files.each do |file|
+          File.expects(:exists?).with(file).returns(true)
+        end
+        @action.prepare
+      end
+
+      should "raise an exception when an include file does not exist" do
+        File.expects(:exists?).once.returns(false)
+        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
+      end
+    end
+
+    context "loading export reference" do
+      should "find and store a reference to the export action" do
+        @export = mock("export")
+        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(@export)
+        @action.prepare
+        assert @export.equal?(@action.export_action)
+      end
+
+      should "raise an exception if the export action couldn't be found" do
+        @runner.expects(:find_action).with(Vagrant::Actions::VM::Export).once.returns(nil)
+        assert_raises(Vagrant::Actions::ActionException) { @action.prepare }
+      end
+    end
+  end
+end