vagrantup 0.8.10 → 0.9.0

data/test/unit/vagrant/hosts_test.rb

@@ -0,0 +1,36 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Hosts do
+  let(:registry) { Vagrant::Registry.new }
+
+  it "detects the host that matches true" do
+    foo_klass = Class.new(Vagrant::Hosts::Base) do
+      def self.match?; false; end
+    end
+
+    bar_klass = Class.new(Vagrant::Hosts::Base) do
+      def self.match?; true; end
+    end
+
+    registry.register(:foo, foo_klass)
+    registry.register(:bar, bar_klass)
+
+    described_class.detect(registry).should == bar_klass
+  end
+
+  it "detects the host that matches true with the highest precedence first" do
+    foo_klass = Class.new(Vagrant::Hosts::Base) do
+      def self.match?; true; end
+    end
+
+    bar_klass = Class.new(Vagrant::Hosts::Base) do
+      def self.match?; true; end
+      def self.precedence; 9; end
+    end
+
+    registry.register(:foo, foo_klass)
+    registry.register(:bar, bar_klass)
+
+    described_class.detect(registry).should == bar_klass
+  end
+end

data/test/unit/vagrant/registry_test.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::Registry do
+  let(:instance) { described_class.new }
+
+  it "should return nil for nonexistent items" do
+    instance.get("foo").should be_nil
+  end
+
+  it "should register a simple key/value" do
+    instance.register("foo", "value")
+    instance.get("foo").should == "value"
+  end
+
+  it "should register an item without calling the block yet" do
+    expect do
+      instance.register("foo") do
+        raise Exception, "BOOM!"
+      end
+    end.to_not raise_error
+  end
+
+  it "should call and return the result of a block when asking for the ite" do
+    object = Object.new
+    instance.register("foo") do
+      object
+    end
+
+    instance.get("foo").should eql(object)
+  end
+
+  it "should be enumerable" do
+    instance.register("foo", "foovalue")
+    instance.register("bar", "barvalue")
+
+    keys   = []
+    values = []
+    instance.each do |key, value|
+      keys << key
+      values << value
+    end
+
+    keys.sort.should == ["bar", "foo"]
+    values.sort.should == ["barvalue", "foovalue"]
+  end
+
+  it "should be able to convert to a hash" do
+    instance.register("foo", "foovalue")
+    instance.register("bar", "barvalue")
+
+    result = instance.to_hash
+    result.should be_a(Hash)
+    result["foo"].should == "foovalue"
+    result["bar"].should == "barvalue"
+  end
+end

data/test/unit/vagrant/util/file_checksum_test.rb

@@ -0,0 +1,23 @@
+require File.expand_path("../../../base", __FILE__)
+require 'digest/md5'
+require 'digest/sha1'
+
+require 'vagrant/util/file_checksum'
+
+describe FileChecksum do
+  include_context "unit"
+
+  let(:environment) { isolated_environment }
+
+  it "should return a valid checksum for a file" do
+    file = environment.workdir.join("file")
+    file.open("w+") { |f| f.write("HELLO!") }
+
+    # Check multiple digests
+    instance = described_class.new(file, Digest::MD5)
+    instance.checksum.should == "9ac96c64417b5976a58839eceaa77956"
+
+    instance = described_class.new(file, Digest::SHA1)
+    instance.checksum.should == "264b207c7913e461c43d0f63d2512f4017af4755"
+  end
+end

data/test/unit/vagrant/util/hash_with_indifferent_access_test.rb

@@ -1,39 +1,38 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class HashWithIndifferentAccessUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Util::HashWithIndifferentAccess
-    @instance = @klass.new
-  end
+require "vagrant/util/hash_with_indifferent_access"
+
+describe Vagrant::Util::HashWithIndifferentAccess do
+  let(:instance) { described_class.new }
 
-  should "be a hash" do
-    assert @instance.is_a?(Hash)
+  it "is a Hash" do
+    instance.should be_kind_of(Hash)
   end
 
-  should "allow indifferent access when setting with a string" do
-    @instance["foo"] = "bar"
-    assert_equal "bar", @instance[:foo]
+  it "allows indifferent access when setting with a string" do
+    instance["foo"] = "bar"
+    instance[:foo].should == "bar"
   end
 
-  should "allow indifferent access when setting with a symbol" do
-    @instance[:foo] = "bar"
-    assert_equal "bar", @instance["foo"]
+  it "allows indifferent access when setting with a symbol" do
+    instance[:foo] = "bar"
+    instance["foo"].should == "bar"
   end
 
-  should "allow indifferent key lookup" do
-    @instance["foo"] = "bar"
-    assert @instance.key?(:foo)
-    assert @instance.has_key?(:foo)
-    assert @instance.include?(:foo)
-    assert @instance.member?(:foo)
+  it "allows indifferent key lookup" do
+    instance["foo"] = "bar"
+    instance.key?(:foo).should be
+    instance.has_key?(:foo).should be
+    instance.include?(:foo).should be
+    instance.member?(:foo).should be
   end
 
-  should "forward up block to Hash if given to initializer" do
-    instance = @klass.new do |h,k|
+  it "allows for defaults to be passed in via an initializer block" do
+    instance = described_class.new do |h,k|
       h[k] = "foo"
     end
 
-    assert_equal "foo", instance[:foo]
-    assert_equal "foo", instance["foo"]
+    instance[:foo].should == "foo"
+    instance["bar"].should == "foo"
   end
 end

data/test/unit/vagrant/util/network_ip_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/network_ip"
+
+describe Vagrant::Util::NetworkIP do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::NetworkIP
+    end
+  end
+
+  describe "network address" do
+    it "calculates it properly" do
+      klass.network_address("192.168.2.234", "255.255.255.0").should == "192.168.2.0"
+    end
+  end
+end

data/test/unit/vagrant/util/retryable_test.rb

@@ -1,50 +1,106 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class RetryableUtilTest < Test::Unit::TestCase
-  setup do
-    @klass = Class.new do
+require "vagrant/util/retryable"
+
+describe Vagrant::Util::Retryable do
+  let(:klass) do
+    Class.new do
       extend Vagrant::Util::Retryable
     end
   end
 
-  should "retry specified number of times if exception is raised" do
-    proc = mock("proc")
-    proc.expects(:call).twice
+  it "doesn't retry by default" do
+    tries = 0
+
+    block = lambda do
+      tries += 1
+      raise RuntimeError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(&block) }.
+      to raise_error(RuntimeError)
 
-    assert_raises(RuntimeError) {
-      @klass.retryable(:tries => 2, :on => RuntimeError) do
-        proc.call
-        raise "An error"
-      end
-    }
+    # It should've tried once
+    tries.should == 1
   end
 
-  should "only retry on specified exception" do
-    proc = mock("proc")
-    proc.expects(:call).once
+  it "retries the set number of times" do
+    tries = 0
+
+    block = lambda do
+      tries += 1
+      raise RuntimeError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, &block) }.
+      to raise_error(RuntimeError)
 
-    assert_raises(StandardError) {
-      @klass.retryable(:tries => 5, :on => RuntimeError) do
-        proc.call
-        raise StandardError.new
-      end
-    }
+    # It should've tried all specified times
+    tries.should == 5
   end
 
-  should "retry on multiple exceptions given" do
-    proc = mock("proc")
-    proc.expects(:call).twice
+  it "only retries on the given exception" do
+    tries = 0
 
-    assert_raises(StandardError) {
-      @klass.retryable(:tries => 2, :on => [StandardError, RuntimeError]) do
-        proc.call
-        raise StandardError
-      end
-    }
+    block = lambda do
+      tries += 1
+      raise StandardError, "Try"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, :on => RuntimeError, &block) }.
+      to raise_error(StandardError)
+
+    # It should've never tried since it was a different kind of error
+    tries.should == 1
   end
 
-  should "return the value of the block" do
-    result = @klass.retryable { 7 }
-    assert_equal 7, result
+  it "can retry on multiple types of errors" do
+    tries = 0
+
+    foo_error = Class.new(StandardError)
+    bar_error = Class.new(StandardError)
+
+    block = lambda do
+      tries += 1
+      raise foo_error, "Try" if tries == 1
+      raise bar_error, "Try" if tries == 2
+      raise RuntimeError, "YAY"
+    end
+
+    # It should re-raise the error
+    expect { klass.retryable(:tries => 5, :on => [foo_error, bar_error], &block) }.
+      to raise_error(RuntimeError)
+
+    # It should've never tried since it was a different kind of error
+    tries.should == 3
+  end
+
+  it "doesn't sleep between tries by default" do
+    block = lambda do
+      raise RuntimeError, "Try"
+    end
+
+    # Sleep should never be called
+    klass.should_not_receive(:sleep)
+
+    # Run it.
+    expect { klass.retryable(:tries => 5, &block) }.
+      to raise_error(RuntimeError)
+  end
+
+  it "sleeps specified amount between retries" do
+    block = lambda do
+      raise RuntimeError, "Try"
+    end
+
+    # Sleep should be called between each retry
+    klass.should_receive(:sleep).with(10).exactly(4).times
+
+    # Run it.
+    expect { klass.retryable(:tries => 5, :sleep => 10, &block) }.
+      to raise_error(RuntimeError)
   end
 end

data/test/unit/vagrant_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path("../base", __FILE__)
+
+describe Vagrant do
+  it "has the path to the source root" do
+    described_class.source_root.should == Pathname.new(File.expand_path("../../../", __FILE__))
+  end
+
+  it "has a registry for commands" do
+    described_class.commands.should be_a(Vagrant::Registry)
+  end
+
+  it "has a registry for config keys" do
+    described_class.config_keys.should be_a(Vagrant::Registry)
+  end
+
+  it "has a registry for hosts" do
+    described_class.hosts.should be_a(Vagrant::Registry)
+  end
+
+  it "has a registry for guests" do
+    described_class.guests.should be_a(Vagrant::Registry)
+  end
+
+  it "has a registry for provisioners" do
+    described_class.provisioners.should be_a(Vagrant::Registry)
+  end
+end

data/test/unit_legacy/vagrant/box_collection_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class BoxCollectionTest < Test::Unit::TestCase
+  setup do
+    clean_paths
+
+    @klass = Vagrant::BoxCollection
+  end
+
+  should "load all the boxes from the box path" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    result = @klass.new(vagrant_env)
+    names = result.collect { |b| b.name }.sort
+    assert result.length >= 2
+    assert names.include?("foo")
+    assert names.include?("bar")
+  end
+
+  should "reload the box list" do
+    instance = @klass.new(vagrant_env)
+    amount = instance.length
+
+    vagrant_box("foo")
+
+    instance.reload!
+    assert_equal (amount + 1), instance.length
+  end
+
+  should "find a specific box" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    instance = @klass.new(vagrant_env)
+    result = instance.find("foo")
+    assert result
+    assert_equal "foo", result.name
+  end
+
+  should "return nil if it couldn't find a specific box" do
+    instance = @klass.new(vagrant_env)
+    assert_nil instance.find("thisshouldnotexist")
+  end
+end

data/test/unit_legacy/vagrant/box_test.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    setup do
+      @env = vagrant_env
+    end
+
+    context "adding" do
+      setup do
+        @name = "foo"
+        @uri = "bar"
+      end
+
+      should "create a new instance, set the variables, and add it" do
+        box = mock("box")
+        box.expects(:uri=).with(@uri)
+        box.expects(:add).once
+        Vagrant::Box.expects(:new).with(@env, @name).returns(box)
+        Vagrant::Box.add(@env, @name, @uri)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Vagrant::Box.new(vagrant_env, "foo")
+    end
+
+    should "raise an exception if a box exists with the name we're attempting to add" do
+      vagrant_box(@box.name)
+
+      assert_raises(Vagrant::Errors::BoxAlreadyExists) {
+        @box.add
+      }
+    end
+
+    should "execute the Add action when add is called" do
+      @box.env.actions.expects(:run).with(:box_add, { "box" => @box, "validate" => false })
+      @box.add
+    end
+
+    context "box directory" do
+      should "return the boxes_path joined with the name" do
+        assert_equal @box.env.boxes_path.join(@box.name), @box.directory
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box, "validate" => false })
+        @box.destroy
+      end
+    end
+
+    context "repackaging" do
+      should "execute the repackage action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "validate" => false })
+        @box.repackage
+      end
+
+      should "forward given options into the action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar", "validate" => false })
+        @box.repackage("foo" => "bar")
+      end
+    end
+
+    context "ovf file" do
+      should "be the directory joined with the config ovf file" do
+        assert_equal @box.directory.join(@box.env.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end

data/test/unit_legacy/vagrant/command/base_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CommandBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command::Base
+    @env = vagrant_env
+  end
+
+  context "initialization" do
+    should "require an environment" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { @klass.new([], {}, {}) }
+      assert_nothing_raised { @klass.new([], {}, { :env => @env }) }
+    end
+  end
+
+  context "extracting a name from a usage string" do
+    should "extract properly" do
+      assert_equal "init", @klass.extract_name_from_usage("init")
+      assert_equal "init", @klass.extract_name_from_usage("init [foo] [bar]")
+      assert_equal "ssh-config", @klass.extract_name_from_usage("ssh-config")
+    end
+  end
+end