vagrant-lxc 0.0.1 → 0.0.2

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

@@ -1,287 +0,0 @@
-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/vendor/vagrant/test/unit/vagrant/plugin/v2/provider_test.rb

@@ -1,18 +0,0 @@
-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/vendor/vagrant/test/unit/vagrant/registry_test.rb

@@ -1,128 +0,0 @@
-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 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
-      object
-    end
-
-    instance.get("foo").should eql(object)
-  end
-
-  it "should be able to get the item with []" do
-    object = Object.new
-    instance.register("foo") { object }
-
-    instance["foo"].should eql(object)
-  end
-
-  it "should cache the result of the item so they can be modified" do
-    # Make the proc generate a NEW array each time
-    instance.register("foo") { [] }
-
-    # Test that modifying the result modifies the actual cached
-    # value. This verifies we're caching.
-    instance.get("foo").should == []
-    instance.get("foo") << "value"
-    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" }
-
-    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
-
-  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/vendor/vagrant/test/unit/vagrant/util/ansi_escape_code_remover_test.rb

@@ -1,16 +0,0 @@
-require File.expand_path("../../../base", __FILE__)
-
-require "vagrant/util/ansi_escape_code_remover"
-
-describe Vagrant::Util::ANSIEscapeCodeRemover do
-  let(:klass) do
-    Class.new do
-      extend Vagrant::Util::ANSIEscapeCodeRemover
-    end
-  end
-
-  it "should remove ANSI escape codes" do
-    klass.remove_ansi_escape_codes("\e[Hyo").should == "yo"
-  end
-end
-