vagrant 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