vagrantup 1.0.7 → 1.1.0

data/test/unit/vagrant/{command/base_test.rb → plugin/v1/command_test.rb}

@@ -1,7 +1,7 @@
-require File.expand_path("../../../base", __FILE__)
+require File.expand_path("../../../../base", __FILE__)
 require 'optparse'
 
-describe Vagrant::Command::Base do
+describe Vagrant::Plugin::V1::Command do
   describe "parsing options" do
     let(:klass) do
       Class.new(described_class) do
@@ -68,13 +68,6 @@ describe Vagrant::Command::Base do
         to raise_error(Vagrant::Errors::NoEnvironmentError)
     end
 
-    it "should raise an exception if a name is given in a non-multivm environment" do
-      environment.stub(:multivm?).and_return(false)
-
-      expect { instance.with_target_vms("foo") }.
-        to raise_error(Vagrant::Errors::MultiVMEnvironmentRequired)
-    end
-
     it "should yield every VM in order is no name is given" do
       foo_vm = double("foo")
       foo_vm.stub(:name).and_return("foo")

data/test/unit/vagrant/plugin/v1/communicator_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::Communicator do
+  let(:machine)  { Object.new }
+
+  it "should not match by default" do
+    described_class.match?(machine).should_not be
+  end
+end

data/test/unit/vagrant/plugin/v1/config_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::Config do
+  include_context "unit"
+
+  let(:foo_class) do
+    Class.new(described_class) do
+      attr_accessor :one
+      attr_accessor :two
+    end
+  end
+
+  it "has an UNSET_VALUE constant" do
+    value = described_class.const_get("UNSET_VALUE")
+    value.should be_kind_of Object
+    value.should eql(described_class.const_get("UNSET_VALUE"))
+  end
+
+  describe "merging" do
+    it "should merge by default by simply copying each instance variable" do
+      one = foo_class.new
+      one.one = 2
+      one.two = 1
+
+      two = foo_class.new
+      two.two = 5
+
+      result = one.merge(two)
+      result.one.should == 2
+      result.two.should == 5
+    end
+
+    it "doesn't merge values that start with a double underscore" do
+      one = foo_class.new
+      one.one = 1
+      one.two = 1
+      one.instance_variable_set(:@__bar, "one")
+
+      two = foo_class.new
+      two.two = 2
+      two.instance_variable_set(:@__bar, "two")
+
+      # Merge and verify
+      result = one.merge(two)
+      result.one.should == 1
+      result.two.should == 2
+      result.instance_variable_get(:@__bar).should be_nil
+    end
+  end
+end

data/test/unit/vagrant/plugin/v1/host_test.rb

@@ -0,0 +1,5 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::Host do
+  # No tests.
+end

data/test/unit/vagrant/plugin/v1/manager_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::Manager do
+  include_context "unit"
+
+  let(:instance) { described_class.new }
+
+  def plugin
+    p = Class.new(Vagrant.plugin("1"))
+    yield p
+    p
+  end
+
+  it "should enumerate registered communicator classes" do
+    pA = plugin do |p|
+      p.communicator("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.communicator("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.communicators.length.should == 2
+    instance.communicators[:foo].should == "bar"
+    instance.communicators[:bar].should == "baz"
+  end
+
+  it "should enumerate registered configuration classes" do
+    pA = plugin do |p|
+      p.config("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.config("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.config.length.should == 2
+    instance.config[:foo].should == "bar"
+    instance.config[:bar].should == "baz"
+  end
+
+  it "should enumerate registered upgrade safe config classes" do
+    pA = plugin do |p|
+      p.config("foo", true) { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.config("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.config_upgrade_safe.length.should == 1
+    instance.config_upgrade_safe[:foo].should == "bar"
+  end
+
+  it "should enumerate registered guest classes" do
+    pA = plugin do |p|
+      p.guest("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.guest("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.guests.length.should == 2
+    instance.guests[:foo].should == "bar"
+    instance.guests[:bar].should == "baz"
+  end
+
+  it "should enumerate registered host classes" do
+    pA = plugin do |p|
+      p.host("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.host("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.hosts.length.should == 2
+    instance.hosts[:foo].should == "bar"
+    instance.hosts[:bar].should == "baz"
+  end
+
+  it "should enumerate registered provider classes" do
+    pA = plugin do |p|
+      p.provider("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.provider("bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.providers.length.should == 2
+    instance.providers[:foo].should == "bar"
+    instance.providers[:bar].should == "baz"
+  end
+end

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

@@ -0,0 +1,267 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::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 action hooks" do
+      plugin = Class.new(described_class) do
+        action_hook("foo") { "bar" }
+      end
+
+      hooks = plugin.action_hook("foo")
+      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::V1::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.config[: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.config[:foo]
+      }.to raise_error(StandardError)
+    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