vagrantup 1.0.7 → 1.1.0

data/test/unit/vagrant/plugin/v2/plugin_test.rb

@@ -0,0 +1,287 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Plugin do
+  after(:each) do
+    # We want to make sure that the registered plugins remains empty
+    # after each test.
+    described_class.manager.reset!
+  end
+
+  it "should be able to set and get the name" do
+    plugin = Class.new(described_class) do
+      name "foo"
+    end
+
+    plugin.name.should == "foo"
+  end
+
+  it "should be able to set and get the description" do
+    plugin = Class.new(described_class) do
+      description "bar"
+    end
+
+    plugin.description.should == "bar"
+  end
+
+  describe "action hooks" do
+    it "should register on all actions by default" do
+      plugin = Class.new(described_class) do
+        action_hook("foo") { "bar" }
+      end
+
+      hooks_registry = plugin.components.action_hooks
+      hooks = hooks_registry[described_class.const_get("ALL_ACTIONS")]
+      hooks.length.should == 1
+      hooks[0].call.should == "bar"
+    end
+
+    it "should register for a specific action by default" do
+      plugin = Class.new(described_class) do
+        action_hook("foo", :bar) { "bar" }
+      end
+
+      hooks_registry = plugin.components.action_hooks
+      hooks = hooks_registry[:bar]
+      hooks.length.should == 1
+      hooks[0].call.should == "bar"
+    end
+  end
+
+  describe "commands" do
+    it "should register command classes" do
+      plugin = Class.new(described_class) do
+        command("foo") { "bar" }
+      end
+
+      plugin.command[:foo].should == "bar"
+    end
+
+    ["spaces bad", "sym^bols"].each do |bad|
+      it "should not allow bad command name: #{bad}" do
+        plugin = Class.new(described_class)
+
+        expect { plugin.command(bad) {} }.
+          to raise_error(Vagrant::Plugin::V2::InvalidCommandName)
+      end
+    end
+
+    it "should lazily register command classes" do
+      # Below would raise an error if the value of the command class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        command("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the command key that
+      # a proper error is raised.
+      expect {
+        plugin.command[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "communicators" do
+    it "should register communicator classes" do
+      plugin = Class.new(described_class) do
+        communicator("foo") { "bar" }
+      end
+
+      plugin.communicator[:foo].should == "bar"
+    end
+
+    it "should lazily register communicator classes" do
+      # Below would raise an error if the value of the class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        communicator("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.communicator[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "configuration" do
+    it "should register configuration classes" do
+      plugin = Class.new(described_class) do
+        config("foo") { "bar" }
+      end
+
+      plugin.components.configs[:top][:foo].should == "bar"
+    end
+
+    it "should lazily register configuration classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+        config("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.components.configs[:top][:foo]
+      }.to raise_error(StandardError)
+    end
+
+    it "should register configuration classes for providers" do
+      plugin = Class.new(described_class) do
+        config("foo", :provider) { "bar" }
+      end
+
+      plugin.components.configs[:provider][:foo].should == "bar"
+    end
+  end
+
+  describe "guests" do
+    it "should register guest classes" do
+      plugin = Class.new(described_class) do
+        guest("foo") { "bar" }
+      end
+
+      plugin.guest[:foo].should == "bar"
+    end
+
+    it "should lazily register guest classes" do
+      # Below would raise an error if the value of the guest class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          guest("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the guest key that
+      # a proper error is raised.
+      expect {
+        plugin.guest[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "hosts" do
+    it "should register host classes" do
+      plugin = Class.new(described_class) do
+        host("foo") { "bar" }
+      end
+
+      plugin.host[:foo].should == "bar"
+    end
+
+    it "should lazily register host classes" do
+      # Below would raise an error if the value of the host class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          host("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the host key that
+      # a proper error is raised.
+      expect {
+        plugin.host[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "providers" do
+    it "should register provider classes" do
+      plugin = Class.new(described_class) do
+        provider("foo") { "bar" }
+      end
+
+      plugin.provider[:foo].should == "bar"
+    end
+
+    it "should lazily register provider classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          provider("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.provider[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "provisioners" do
+    it "should register provisioner classes" do
+      plugin = Class.new(described_class) do
+        provisioner("foo") { "bar" }
+      end
+
+      plugin.provisioner[:foo].should == "bar"
+    end
+
+    it "should lazily register provisioner classes" do
+      # Below would raise an error if the value of the config class was
+      # evaluated immediately. By asserting that this does not raise an
+      # error, we verify that the value is actually lazily loaded
+      plugin = nil
+      expect {
+        plugin = Class.new(described_class) do
+          provisioner("foo") { raise StandardError, "FAIL!" }
+        end
+      }.to_not raise_error
+
+      # Now verify when we actually get the configuration key that
+      # a proper error is raised.
+      expect {
+        plugin.provisioner[:foo]
+      }.to raise_error(StandardError)
+    end
+  end
+
+  describe "plugin registration" do
+    let(:manager) { described_class.manager }
+
+    it "should have no registered plugins" do
+      manager.registered.should be_empty
+    end
+
+    it "should register a plugin when a name is set" do
+      plugin = Class.new(described_class) do
+        name "foo"
+      end
+
+      manager.registered.should == [plugin]
+    end
+
+    it "should register a plugin only once" do
+      plugin = Class.new(described_class) do
+        name "foo"
+        name "bar"
+      end
+
+      manager.registered.should == [plugin]
+    end
+  end
+end

data/test/unit/vagrant/plugin/v2/provider_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Provider do
+  let(:machine)  { Object.new }
+  let(:instance) { described_class.new(machine) }
+
+  it "should return nil by default for actions" do
+    instance.action(:whatever).should be_nil
+  end
+
+  it "should return nil by default for ssh info" do
+    instance.ssh_info.should be_nil
+  end
+
+  it "should return nil by default for state" do
+    instance.state.should be_nil
+  end
+end

data/test/unit/vagrant/registry_test.rb

@@ -8,7 +8,7 @@ describe Vagrant::Registry do
   end
 
   it "should register a simple key/value" do
-    instance.register("foo", "value")
+    instance.register("foo") { "value" }
     instance.get("foo").should == "value"
   end
 
@@ -20,6 +20,11 @@ describe Vagrant::Registry do
     end.to_not raise_error
   end
 
+  it "should raise an error if no block is given" do
+    expect { instance.register("foo") }.
+      to raise_error(ArgumentError)
+  end
+
   it "should call and return the result of a block when asking for the item" do
     object = Object.new
     instance.register("foo") do
@@ -47,9 +52,15 @@ describe Vagrant::Registry do
     instance.get("foo").should == ["value"]
   end
 
+  it "should be able to check if a key exists" do
+    instance.register("foo") { "bar" }
+    instance.should have_key("foo")
+    instance.should_not have_key("bar")
+  end
+
   it "should be enumerable" do
-    instance.register("foo", "foovalue")
-    instance.register("bar", "barvalue")
+    instance.register("foo") { "foovalue" }
+    instance.register("bar") { "barvalue" }
 
     keys   = []
     values = []
@@ -63,12 +74,55 @@ describe Vagrant::Registry do
   end
 
   it "should be able to convert to a hash" do
-    instance.register("foo", "foovalue")
-    instance.register("bar", "barvalue")
+    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
+
+  describe "merging" do
+    it "should merge in another registry" do
+      one = described_class.new
+      two = described_class.new
+
+      one.register("foo") { raise "BOOM!" }
+      two.register("bar") { raise "BAM!" }
+
+      three = one.merge(two)
+      expect { three["foo"] }.to raise_error("BOOM!")
+      expect { three["bar"] }.to raise_error("BAM!")
+    end
+
+    it "should NOT merge in the cache" do
+      one = described_class.new
+      two = described_class.new
+
+      one.register("foo") { [] }
+      one["foo"] << 1
+
+      two.register("bar") { [] }
+      two["bar"] << 2
+
+      three = one.merge(two)
+      three["foo"].should == []
+      three["bar"].should == []
+    end
+  end
+
+  describe "merge!" do
+    it "should merge into self" do
+      one = described_class.new
+      two = described_class.new
+
+      one.register("foo") { "foo" }
+      two.register("bar") { "bar" }
+
+      one.merge!(two)
+      one["foo"].should == "foo"
+      one["bar"].should == "bar"
+    end
+  end
 end

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

@@ -0,0 +1,48 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/util/scoped_hash_override"
+
+describe Vagrant::Util::ScopedHashOverride do
+  let(:klass) do
+    Class.new do
+      extend Vagrant::Util::ScopedHashOverride
+    end
+  end
+
+  it "should not mess with non-overrides" do
+    original = {
+      :key => "value",
+      :another_value => "foo"
+    }
+
+    klass.scoped_hash_override(original, "foo").should == original
+  end
+
+  it "should override if the scope matches" do
+    original = {
+      :key => "value",
+      :scope__key => "replaced"
+    }
+
+    expected = {
+      :key => "replaced"
+    }
+
+    klass.scoped_hash_override(original, "scope").should == expected
+  end
+
+  it "should ignore non-matching scopes" do
+    original = {
+      :key => "value",
+      :scope__key => "replaced",
+      :another__key => "value"
+    }
+
+    expected = {
+      :key => "replaced",
+      :another__key => "value"
+    }
+
+    klass.scoped_hash_override(original, "scope").should == expected
+  end
+end