vagrant-lxc 0.0.1 → 0.0.2

data/vendor/vagrant/test/unit/vagrant/plugin/v1/command_test.rb

@@ -1,143 +0,0 @@
-require File.expand_path("../../../../base", __FILE__)
-require 'optparse'
-
-describe Vagrant::Plugin::V1::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 |opts|
-        opts.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(:environment) do
-      env = double("environment")
-      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).and_return("foo")
-
-      bar_vm = double("bar")
-      bar_vm.stub(:name).and_return("bar")
-
-      environment.stub(:multivm? => true,
-                       :vms => { "foo" => foo_vm, "bar" => bar_vm },
-                       :vms_ordered => [foo_vm, 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(:multivm? => true, :vms => {})
-
-      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).and_return(:foo)
-
-      environment.stub(:multivm? => true,
-                       :vms => { :foo => foo_vm, :bar => nil })
-
-      vms = []
-      instance.with_target_vms("foo") { |vm| vms << vm }
-      vms.should == [foo_vm]
-    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/vendor/vagrant/test/unit/vagrant/plugin/v1/communicator_test.rb

@@ -1,9 +0,0 @@
-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/vendor/vagrant/test/unit/vagrant/plugin/v1/config_test.rb

@@ -1,50 +0,0 @@
-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/vendor/vagrant/test/unit/vagrant/plugin/v1/host_test.rb

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

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

@@ -1,114 +0,0 @@
-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/vendor/vagrant/test/unit/vagrant/plugin/v1/plugin_test.rb

@@ -1,267 +0,0 @@
-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