vagrantup 0.4.3.dev → 0.5.0

data/test/vagrant/actions/base_test.rb

@@ -1,32 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class BaseActionTest < Test::Unit::TestCase
-  should "include the util class so subclasses have access to it" do
-    assert Vagrant::Actions::Base.include?(Vagrant::Util)
-  end
-
-  context "base instance" do
-    setup do
-      @mock_vm = mock("vm")
-      @base = Vagrant::Actions::Base.new(@mock_vm)
-    end
-
-    should "allow read-only access to the runner" do
-      assert_equal @mock_vm, @base.runner
-    end
-
-    should "implement prepare which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:prepare)
-        @base.prepare
-      end
-    end
-
-    should "implement the execute! method which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:execute!)
-        @base.execute!
-      end
-    end
-  end
-end

data/test/vagrant/actions/box/add_test.rb

@@ -1,36 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class AddBoxActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Add)
-  end
-
-  context "prepare" do
-    setup do
-      @default_order = [Vagrant::Actions::Box::Download, Vagrant::Actions::Box::Unpackage, Vagrant::Actions::Box::Verify]
-      @runner.stubs(:directory).returns("foo")
-      File.stubs(:exists?).returns(false)
-    end
-
-    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)
-      end
-    end
-
-    should "setup the proper sequence of actions" do
-      setup_action_expectations
-      @action.prepare
-    end
-
-    should "result in an action exception if the box already exists" do
-      File.expects(:exists?).once.returns(true)
-      @runner.expects(:name).once.returns('foo')
-      @runner.expects(:add_action).never
-      assert_raise Vagrant::Actions::ActionException do
-        @action.prepare
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class DestroyBoxActionTest < Test::Unit::TestCase
-  setup do
-    @name = "foo"
-    @dir = "foo"
-    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Destroy)
-    @runner.stubs(:directory).returns(@dir)
-  end
-
-  context "executing" do
-    should "rm_rf the directory" do
-      FileUtils.expects(:rm_rf).with(@dir).once
-      @action.execute!
-    end
-  end
-end

data/test/vagrant/actions/box/download_test.rb

@@ -1,137 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class DownloadBoxActionTest < Test::Unit::TestCase
-  setup do
-    @uri = "foo.com"
-    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Download)
-    @runner.stubs(:uri).returns(@uri)
-    @runner.stubs(:temp_path=)
-
-    @runner.env.stubs(:tmp_path).returns("foo")
-  end
-
-  context "preparing" do
-    setup do
-      @downloader = mock("downloader")
-      Vagrant::Downloaders::File.any_instance.stubs(:prepare)
-      Vagrant::Downloaders::HTTP.any_instance.stubs(:prepare)
-    end
-
-    should "raise an exception if no URI type is matched" do\
-      Vagrant::Downloaders::File.expects(:match?).returns(false)
-      Vagrant::Downloaders::HTTP.expects(:match?).returns(false)
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
-      }
-    end
-
-    should "call #prepare on the downloader" do
-      @downloader.expects(:prepare).with(@runner.uri).once
-      Vagrant::Downloaders::File.expects(:new).returns(@downloader)
-      expect_file
-      @action.prepare
-    end
-
-    should "set the downloader to file if the uri provided is a file" do
-      expect_file
-      @action.prepare
-      assert @action.downloader.is_a?(Vagrant::Downloaders::File)
-    end
-
-    should "set the downloader to HTTP if the uri provided is a valid url" do
-      expect_http
-      @action.prepare
-      assert @action.downloader.is_a?(Vagrant::Downloaders::HTTP)
-    end
-
-    def expect_file
-      Vagrant::Downloaders::File.expects(:match?).returns(true)
-      Vagrant::Downloaders::HTTP.expects(:match?).returns(false)
-    end
-
-    def expect_http
-      Vagrant::Downloaders::File.expects(:match?).returns(false)
-      Vagrant::Downloaders::HTTP.expects(:match?).returns(true)
-    end
-  end
-
-  context "executing" do
-    setup do
-      @path = "foo"
-
-      @tempfile = mock("tempfile")
-      @tempfile.stubs(:path).returns(@path)
-
-      @action.stubs(:with_tempfile).yields(@tempfile)
-      @action.stubs(:download_to)
-    end
-
-    should "make a tempfile and copy the URI contents to it" do
-      @action.expects(:with_tempfile).yields(@tempfile)
-      @action.expects(:download_to).with(@tempfile)
-      @action.execute!
-    end
-
-    should "save the tempfile path" do
-      @runner.expects(:temp_path=).with(@path).once
-      @action.execute!
-    end
-  end
-
-  context "rescue" do
-    should "call cleanup method" do
-      @action.expects(:cleanup).once
-      @action.rescue(nil)
-    end
-  end
-
-  context "tempfile" do
-    should "create a tempfile in the vagrant tmp directory" do
-      File.expects(:open).with { |name, bitmask|
-        name =~ /#{Vagrant::Actions::Box::Download::BASENAME}/ &&  name =~ /#{@runner.env.tmp_path}/
-      }.once
-      @action.with_tempfile
-    end
-
-    should "yield the tempfile object" do
-      @tempfile = mock("tempfile")
-      File.expects(:open).yields(@tempfile)
-
-      @action.with_tempfile do |otherfile|
-        assert @tempfile.equal?(otherfile)
-      end
-    end
-  end
-
-  context "cleaning up" do
-    setup do
-      @temp_path = "foo"
-      @runner.stubs(:temp_path).returns(@temp_path)
-      File.stubs(:exist?).returns(true)
-    end
-
-    should "delete the temporary file if it exists" do
-      File.expects(:unlink).with(@temp_path).once
-      @action.cleanup
-    end
-
-    should "not delete anything if it doesn't exist" do
-      File.stubs(:exist?).returns(false)
-      File.expects(:unlink).never
-      @action.cleanup
-    end
-  end
-
-  context "downloading" do
-    setup do
-      @downloader = mock("downloader")
-      @action.stubs(:downloader).returns(@downloader)
-    end
-
-    should "call download! on the download with the URI and tempfile" do
-      tempfile = "foo"
-      @downloader.expects(:download!).with(@runner.uri, tempfile)
-      @action.download_to(tempfile)
-    end
-  end
-end

data/test/vagrant/actions/box/unpackage_test.rb

@@ -1,99 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class UnpackageBoxActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Unpackage)
-    @runner.stubs(:name).returns("foo")
-    @runner.stubs(:temp_path).returns("bar")
-
-    @runner.env.stubs(:boxes_path).returns("bar")
-  end
-
-  context "executing" do
-    setup do
-      @runner.stubs(:invoke_around_callback).yields
-    end
-
-    should "execute the proper actions in the proper order" do
-      exec_seq = sequence("exec_seq")
-      @action.expects(:setup_box_dir).in_sequence(exec_seq)
-      @action.expects(:decompress).in_sequence(exec_seq)
-      @action.execute!
-    end
-
-    should "execute it in a around block" do
-      @runner.expects(:invoke_around_callback).with(:unpackage).once
-      @action.execute!
-    end
-  end
-
-  context "rescuing" do
-    setup do
-      File.stubs(:directory?).returns(false)
-      FileUtils.stubs(:rm_rf)
-
-      @box_dir = mock("foo")
-      @action.stubs(:box_dir).returns(@box_dir)
-    end
-
-    should "do nothing if a directory doesn't exist" do
-      FileUtils.expects(:rm_rf).never
-      @action.rescue(nil)
-    end
-
-    should "remove the box directory if it exists" do
-      File.expects(:directory?).returns(true)
-      FileUtils.expects(:rm_rf).with(@box_dir).once
-      @action.rescue(nil)
-    end
-  end
-
-  context "box directory" do
-    should "return the runner directory" do
-      result = mock("object")
-      @runner.expects(:directory).once.returns(result)
-      assert result.equal?(@action.box_dir)
-    end
-  end
-
-  context "setting up the box directory" do
-    setup do
-      File.stubs(:directory?).returns(false)
-      FileUtils.stubs(:mkdir_p)
-
-      @box_dir = "foo"
-      @action.stubs(:box_dir).returns(@box_dir)
-    end
-
-    should "error and exit if the directory exists" do
-      File.expects(:directory?).returns(true)
-      @action.expects(:error_and_exit).with(:box_already_exists, :box_name => @runner.name).once
-      @action.setup_box_dir
-    end
-
-    should "create the directory" do
-      FileUtils.expects(:mkdir_p).with(@box_dir).once
-      @action.setup_box_dir
-    end
-  end
-
-  context "decompressing" do
-    setup do
-      @box_dir = "foo"
-
-      @action.stubs(:box_dir).returns(@box_dir)
-      Dir.stubs(:chdir).yields
-      Archive::Tar::Minitar.stubs(:unpack)
-    end
-
-    should "change to the box directory" do
-      Dir.expects(:chdir).with(@box_dir)
-      @action.decompress
-    end
-
-    should "open the tar file within the new directory, and extract it all" do
-      Archive::Tar::Minitar.expects(:unpack).with(@runner.temp_path, @box_dir).once
-      @action.decompress
-    end
-  end
-end

data/test/vagrant/actions/box/verify_test.rb

@@ -1,44 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '..', 'test_helper')
-
-class VerifyBoxActionTest < Test::Unit::TestCase
-  setup do
-    @runner, @vm, @action = mock_action(Vagrant::Actions::Box::Verify)
-    @runner.stubs(:name).returns("foo")
-    @runner.stubs(:temp_path).returns("bar")
-  end
-
-  context "executing" do
-    should "execute the proper actions in the proper order" do
-      exec_seq = sequence("exec_seq")
-      @action.expects(:reload_configuration).in_sequence(exec_seq)
-      @action.expects(:verify_appliance).in_sequence(exec_seq)
-      @action.execute!
-    end
-  end
-
-  context "reloading configuration" do
-    should "set the new box, load box, then load config" do
-      reload_seq = sequence("reload_seq")
-      @runner.env.config.vm.expects(:box=).with(@runner.name).in_sequence(reload_seq)
-      @runner.env.expects(:load_box!).in_sequence(reload_seq)
-      @runner.env.expects(:load_config!).in_sequence(reload_seq)
-      @action.reload_configuration
-    end
-  end
-
-  context "verifying appliance" do
-    setup do
-      @runner.stubs(:ovf_file).returns("foo")
-    end
-
-    should "create new appliance and return true if succeeds" do
-      VirtualBox::Appliance.expects(:new).with(@runner.ovf_file)
-      assert_nothing_raised { @action.verify_appliance }
-    end
-
-    should "return false if an exception is raised" do
-      VirtualBox::Appliance.expects(:new).with(@runner.ovf_file).raises(VirtualBox::Exceptions::FileErrorException)
-      assert_raises(Vagrant::Actions::ActionException) { @action.verify_appliance }
-    end
-  end
-end

data/test/vagrant/actions/collection_test.rb

@@ -1,113 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class CollectionTest < Test::Unit::TestCase
-  class MockAction; end
-  class MockActionOther; end
-
-  context "checking uniqueness" do
-    setup do
-      @actions = Vagrant::Actions::Collection.new([1])
-    end
-
-    should "return true if there are duplicate classes in the collection" do
-      @actions << 1
-      assert @actions.duplicates?
-    end
-
-    should "return false it all the classes are unique" do
-      @actions << 1.0 << "foo"
-      assert !@actions.duplicates?
-    end
-
-    should "raise an exception when there are duplicates" do
-      @actions << 1
-      assert_raise Vagrant::Actions::DuplicateActionException do
-        @actions.duplicates!
-      end
-    end
-
-    should "not raise an exception when there are no duplicates" do
-      @actions << 1.0 << "foo"
-      assert_nothing_raised do
-        @actions.duplicates!
-      end
-    end
-  end
-
-  context "verifying dependencies" do
-    setup do
-      @mock_action = mock('action')
-      @mock_action.stubs(:class).returns(MockAction)
-
-      @mock_action2 = mock('action2')
-      @mock_action2.stubs(:class).returns(MockActionOther)
-      # see test_helper
-      stub_default_action_dependecies(@mock_action)
-      stub_default_action_dependecies(@mock_action2)
-    end
-
-    context "that come before an action" do
-      setup do
-        @mock_action.stubs(:follows).returns([MockActionOther])
-      end
-      should "raise an exception if they are not met" do
-        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
-          collection.new([@mock_action]).dependencies!
-        end
-      end
-
-      should "not raise an exception if they are met" do
-        assert_nothing_raised do
-          collection.new([@mock_action2, @mock_action]).dependencies!
-        end
-      end
-    end
-
-    context "that follow an an action" do
-      setup do
-        @mock_action.stubs(:precedes).returns([MockActionOther])
-      end
-
-      should "raise an exception if they are not met" do
-        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
-          collection.new([@mock_action]).dependencies!
-        end
-      end
-
-      should "not raise an exception if they are met" do
-        assert_nothing_raised do
-          collection.new([@mock_action, @mock_action2]).dependencies!
-        end
-      end
-    end
-
-    context "that are before and after an action" do
-      setup do
-        @mock_action.stubs(:precedes).returns([MockActionOther])
-        @mock_action.stubs(:follows).returns([MockActionOther])
-      end
-
-      should "raise an exception if they are met" do
-        assert_raise Vagrant::Actions::DependencyNotSatisfiedException do
-          collection.new([@mock_action2, @mock_action]).dependencies!
-        end
-      end
-
-      should "not raise and exception if they are met" do
-        assert_nothing_raised do
-          collection.new([@mock_action2, @mock_action, @mock_action2]).dependencies!
-        end
-      end
-    end
-  end
-
-  context "klasses" do
-    should "return a list of the collection element's classes" do
-      @action = mock('action')
-      assert_equal collection.new([@action]).klasses, [@action.class]
-      assert_equal collection.new([@action, 1.0, "foo"]).klasses, [@action.class, Float, String]
-    end
-  end
-
-  def collection; Vagrant::Actions::Collection end
-end