tnargav 1.3.5 → 1.3.6

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

@@ -0,0 +1,18 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V1::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/plugin/v2/command_test.rb

@@ -0,0 +1,238 @@
+require File.expand_path("../../../../base", __FILE__)
+require 'optparse'
+
+describe Vagrant::Plugin::V2::Command do
+  describe "parsing options" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :parse_options
+      end
+    end
+
+    it "returns the remaining arguments" do
+      options = {}
+      opts = OptionParser.new do |o|
+        o.on("-f") do |f|
+          options[:f] = f
+        end
+      end
+
+      result = klass.new(["-f", "foo"], nil).parse_options(opts)
+
+      # Check the results
+      options[:f].should be
+      result.should == ["foo"]
+    end
+
+    it "creates an option parser if none is given" do
+      result = klass.new(["foo"], nil).parse_options(nil)
+      result.should == ["foo"]
+    end
+
+    ["-h", "--help"].each do |help_string|
+      it "returns nil and prints the help if '#{help_string}' is given" do
+        instance = klass.new([help_string], nil)
+        instance.should_receive(:safe_puts)
+        instance.parse_options(OptionParser.new).should be_nil
+      end
+    end
+
+    it "raises an error if invalid options are given" do
+      instance = klass.new(["-f"], nil)
+      expect { instance.parse_options(OptionParser.new) }.
+        to raise_error(Vagrant::Errors::CLIInvalidOptions)
+    end
+  end
+
+  describe "target VMs" do
+    let(:klass) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :with_target_vms
+      end
+    end
+
+    let(:default_provider) { :virtualbox }
+
+    let(:environment) do
+      env = double("environment")
+      env.stub(:active_machines => [])
+      env.stub(:default_provider => default_provider)
+      env.stub(:root_path => "foo")
+      env
+    end
+
+    let(:instance)    { klass.new([], environment) }
+
+    it "should raise an exception if a root_path is not available" do
+      environment.stub(:root_path => nil)
+
+      expect { instance.with_target_vms }.
+        to raise_error(Vagrant::Errors::NoEnvironmentError)
+    end
+
+    it "should yield every VM in order is no name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name => "foo", :provider => :foobarbaz)
+
+      bar_vm = double("bar")
+      bar_vm.stub(:name => "bar", :provider => :foobarbaz)
+
+      environment.stub(:machine_names => [:foo, :bar])
+      environment.stub(:machine).with(:foo, default_provider).and_return(foo_vm)
+      environment.stub(:machine).with(:bar, default_provider).and_return(bar_vm)
+
+      vms = []
+      instance.with_target_vms do |vm|
+        vms << vm
+      end
+
+      vms.should == [foo_vm, bar_vm]
+    end
+
+    it "raises an exception if the named VM doesn't exist" do
+      environment.stub(:machine_names => [:default])
+      environment.stub(:machine).with(:foo, anything).and_return(nil)
+
+      expect { instance.with_target_vms("foo") }.
+        to raise_error(Vagrant::Errors::VMNotFoundError)
+    end
+
+    it "yields the given VM if a name is given" do
+      foo_vm = double("foo")
+      foo_vm.stub(:name => "foo", :provider => :foobarbaz)
+
+      environment.stub(:machine).with(:foo, default_provider).and_return(foo_vm)
+
+      vms = []
+      instance.with_target_vms("foo") { |vm| vms << vm }
+      vms.should == [foo_vm]
+    end
+
+    it "yields the given VM with proper provider if given" do
+      foo_vm = double("foo")
+      provider = :foobarbaz
+
+      foo_vm.stub(:name => "foo", :provider => provider)
+      environment.stub(:machine).with(:foo, provider).and_return(foo_vm)
+
+      vms = []
+      instance.with_target_vms("foo", :provider => provider) { |vm| vms << vm }
+      vms.should == [foo_vm]
+    end
+
+    it "should raise an exception if an active machine exists with a different provider" do
+      name = :foo
+
+      environment.stub(:active_machines => [[name, :vmware]])
+      expect { instance.with_target_vms(name.to_s, :provider => :foo) }.
+        to raise_error Vagrant::Errors::ActiveMachineWithDifferentProvider
+    end
+
+    it "should default to the active machine provider if no explicit provider requested" do
+      name = :foo
+      provider = :vmware
+      vmware_vm = double("vmware_vm")
+
+      environment.stub(:active_machines => [[name, provider]])
+      environment.stub(:machine).with(name, provider).and_return(vmware_vm)
+      vmware_vm.stub(:name => name, :provider => provider)
+
+      vms = []
+      instance.with_target_vms(name.to_s) { |vm| vms << vm }
+      vms.should == [vmware_vm]
+    end
+
+    it "should use the explicit provider if it maches the active machine" do
+      name = :foo
+      provider = :vmware
+      vmware_vm = double("vmware_vm")
+
+      environment.stub(:active_machines => [[name, provider]])
+      environment.stub(:machine).with(name, provider).and_return(vmware_vm)
+      vmware_vm.stub(:name => name, :provider => provider)
+
+      vms = []
+      instance.with_target_vms(name.to_s, :provider => provider) { |vm| vms << vm }
+      vms.should == [vmware_vm]
+    end
+
+    it "should use the default provider if none is given and none are active" do
+      name = :foo
+      machine = double("machine")
+
+      environment.stub(:machine).with(name, default_provider).and_return(machine)
+      machine.stub(:name => name, :provider => default_provider)
+
+      results = []
+      instance.with_target_vms(name.to_s) { |m| results << m }
+      results.should == [machine]
+    end
+
+    it "should use the primary machine with the active provider" do
+      name = :foo
+      provider = :vmware
+      vmware_vm = double("vmware_vm")
+
+      environment.stub(:active_machines => [[name, provider]])
+      environment.stub(:machine).with(name, provider).and_return(vmware_vm)
+      environment.stub(:machine_names => [])
+      environment.stub(:primary_machine_name => name)
+      vmware_vm.stub(:name => name, :provider => provider)
+
+      vms = []
+      instance.with_target_vms(nil, :single_target => true) { |vm| vms << vm }
+      vms.should == [vmware_vm]
+    end
+
+    it "should use the primary machine with the default provider" do
+      name = :foo
+      machine = double("machine")
+
+      environment.stub(:active_machines => [])
+      environment.stub(:machine).with(name, default_provider).and_return(machine)
+      environment.stub(:machine_names => [])
+      environment.stub(:primary_machine_name => name)
+      machine.stub(:name => name, :provider => default_provider)
+
+      vms = []
+      instance.with_target_vms(nil, :single_target => true) { |vm| vms << machine }
+      vms.should == [machine]
+    end
+  end
+
+  describe "splitting the main and subcommand args" do
+    let(:instance) do
+      Class.new(described_class) do
+        # Make the method public since it is normally protected
+        public :split_main_and_subcommand
+      end.new(nil, nil)
+    end
+
+    it "should work when given all 3 parts" do
+      result = instance.split_main_and_subcommand(["-v", "status", "-h", "-v"])
+      result.should == [["-v"], "status", ["-h", "-v"]]
+    end
+
+    it "should work when given only a subcommand and args" do
+      result = instance.split_main_and_subcommand(["status", "-h"])
+      result.should == [[], "status", ["-h"]]
+    end
+
+    it "should work when given only main flags" do
+      result = instance.split_main_and_subcommand(["-v", "-h"])
+      result.should == [["-v", "-h"], nil, []]
+    end
+
+    it "should work when given only a subcommand" do
+      result = instance.split_main_and_subcommand(["status"])
+      result.should == [[], "status", []]
+    end
+
+    it "works when there are other non-flag args after the subcommand" do
+      result = instance.split_main_and_subcommand(["-v", "box", "add", "-h"])
+      result.should == [["-v"], "box", ["add", "-h"]]
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::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/v2/components_test.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require "vagrant/registry"
+
+describe Vagrant::Plugin::V2::Components do
+  let(:instance) { described_class.new }
+
+  describe "configs" do
+    it "should have configs" do
+      instance.configs.should be_kind_of(Hash)
+    end
+
+    it "should default the values to registries" do
+      instance.configs[:i_probably_dont_exist].should be_kind_of(Vagrant::Registry)
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Config do
+  include_context "unit"
+
+  let(:foo_class) do
+    Class.new(described_class) do
+      attr_accessor :one
+      attr_accessor :two
+    end
+  end
+
+  let(:unset_value) { described_class.const_get("UNSET_VALUE") }
+
+  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 "prefers any set value over an UNSET_VALUE" do
+      one = foo_class.new
+      one.one = 1
+      one.two = 2
+
+      two = foo_class.new
+      two.one = unset_value
+      two.two = 5
+
+      result = one.merge(two)
+      result.one.should == 1
+      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/v2/host_test.rb

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

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

@@ -0,0 +1,174 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Plugin::V2::Manager do
+  include_context "unit"
+
+  let(:instance) { described_class.new }
+
+  def plugin
+    p = Class.new(Vagrant.plugin("2"))
+    yield p
+    p
+  end
+
+  describe "#action_hooks" do
+    it "should contain globally registered hooks" do
+      pA = plugin do |p|
+        p.action_hook("foo") { "bar" }
+      end
+
+      pB = plugin do |p|
+        p.action_hook("bar") { "baz" }
+      end
+
+      instance.register(pA)
+      instance.register(pB)
+
+      result = instance.action_hooks(nil)
+      result.length.should == 2
+      result[0].call.should == "bar"
+      result[1].call.should == "baz"
+    end
+
+    it "should contain specific hooks with globally registered hooks" do
+      pA = plugin do |p|
+        p.action_hook("foo") { "bar" }
+        p.action_hook("foo", :foo) { "bar_foo" }
+        p.action_hook("foo", :bar) { "bar_bar" }
+      end
+
+      pB = plugin do |p|
+        p.action_hook("bar") { "baz" }
+      end
+
+      instance.register(pA)
+      instance.register(pB)
+
+      result = instance.action_hooks(:foo)
+      result.length.should == 3
+      result[0].call.should == "bar"
+      result[1].call.should == "bar_foo"
+      result[2].call.should == "baz"
+    end
+  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.to_hash.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.to_hash.length.should == 2
+    instance.config[:foo].should == "bar"
+    instance.config[:bar].should == "baz"
+  end
+
+  it "should enumerate registered guest classes" do
+    pA = plugin do |p|
+      p.guest("foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.guest("bar", "foo") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.guests.to_hash.length.should == 2
+    instance.guests[:foo].should == ["bar", nil]
+    instance.guests[:bar].should == ["baz", :foo]
+  end
+
+  it "should enumerate registered guest capabilities" do
+    pA = plugin do |p|
+      p.guest_capability("foo", "foo") { "bar" }
+    end
+
+    pB = plugin do |p|
+      p.guest_capability("bar", "foo") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.guest_capabilities.length.should == 2
+    instance.guest_capabilities[:foo][:foo].should == "bar"
+    instance.guest_capabilities[:bar][:foo].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.to_hash.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", foo: "bar") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.providers.to_hash.length.should == 2
+    instance.providers[:foo].should == ["bar", {}]
+    instance.providers[:bar].should == ["baz", { foo: "bar" }]
+  end
+
+  it "provides the collection of registered provider configs" do
+    pA = plugin do |p|
+      p.config("foo", :provider) { "foo" }
+    end
+
+    pB = plugin do |p|
+      p.config("bar", :provider) { "bar" }
+      p.config("baz") { "baz" }
+    end
+
+    instance.register(pA)
+    instance.register(pB)
+
+    instance.provider_configs.to_hash.length.should == 2
+    instance.provider_configs[:foo].should == "foo"
+    instance.provider_configs[:bar].should == "bar"
+  end
+end