vagrant-lxc 0.0.1

data/vendor/vagrant/test/unit/vagrant/box_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path("../../base", __FILE__)
+
+require "pathname"
+
+describe Vagrant::Box do
+  include_context "unit"
+
+  let(:environment)   { isolated_environment }
+
+  let(:box_collection) { Vagrant::BoxCollection.new(environment.boxes_dir) }
+
+  let(:name)          { "foo" }
+  let(:provider)      { :virtualbox }
+  let(:directory)     { environment.box2("foo", :virtualbox) }
+  let(:instance)      { described_class.new(name, provider, directory) }
+
+  it "provides the name" do
+    instance.name.should == name
+  end
+
+  it "provides the provider" do
+    instance.provider.should == provider
+  end
+
+  it "provides the directory" do
+    instance.directory.should == directory
+  end
+
+  it "provides the metadata associated with a box" do
+    data = { "foo" => "bar" }
+
+    # Write the metadata
+    directory.join("metadata.json").open("w") do |f|
+      f.write(JSON.generate(data))
+    end
+
+    # Verify the metadata
+    instance.metadata.should == data
+  end
+
+  describe "destroying" do
+    it "should destroy an existing box" do
+      # Verify that our "box" exists
+      directory.exist?.should be
+
+      # Destroy it
+      instance.destroy!.should be
+
+      # Verify that it is "destroyed"
+      directory.exist?.should_not be
+    end
+
+    it "should not error destroying a non-existent box" do
+      # Get the instance so that it is instantiated
+      box = instance
+
+      # Delete the directory
+      directory.rmtree
+
+      # Destroy it
+      box.destroy!.should be
+    end
+  end
+
+  describe "repackaging" do
+    it "should repackage the box" do
+      test_file_contents = "hello, world!"
+
+      # Put a file in the box directory to verify it is packaged properly
+      # later.
+      directory.join("test_file").open("w") do |f|
+        f.write(test_file_contents)
+      end
+
+      # Repackage our box to some temporary directory
+      box_output_path = temporary_dir.join("package.box")
+      instance.repackage(box_output_path).should be
+
+      # Let's now add this box again under a different name, and then
+      # verify that we get the proper result back.
+      new_box = box_collection.add(box_output_path, "foo2")
+      new_box.directory.join("test_file").read.should == test_file_contents
+    end
+  end
+
+  describe "comparison and ordering" do
+    it "should be equal if the name and provider match" do
+      a = described_class.new("a", :foo, directory)
+      b = described_class.new("a", :foo, directory)
+
+      a.should == b
+    end
+
+    it "should not be equal if the name and provider do not match" do
+      a = described_class.new("a", :foo, directory)
+      b = described_class.new("b", :foo, directory)
+
+      a.should_not == b
+    end
+
+    it "should sort them in order of name then provider" do
+      a = described_class.new("a", :foo, directory)
+      b = described_class.new("b", :foo, directory)
+      c = described_class.new("c", :foo2, directory)
+
+      [c, a, b].sort.should == [a, b, c]
+    end
+  end
+end

data/vendor/vagrant/test/unit/vagrant/cli_test.rb

@@ -0,0 +1,27 @@
+describe Vagrant::CLI do
+  describe "parsing options" do
+    let(:klass) do
+      Class.new(described_class)
+    end
+
+    let(:environment) do
+      ui = double("UI::Silent")
+      ui.stub(:info => "bar")
+      env = double("Vagrant::Environment")
+      env.stub(:ui => ui)
+      env.stub(:root_path => "foo")
+      env.stub(:machine_names => [])
+      env
+    end
+
+    it "returns a non-zero exit status if an invalid command is given" do
+      result = klass.new(["destroypp"], environment).execute
+      result.should_not == 0
+    end
+
+    it "returns an exit status of zero if a valid command is given" do
+      result = klass.new(["destroy"], environment).execute
+      result.should == 0
+    end
+  end
+end

data/vendor/vagrant/test/unit/vagrant/config/loader_test.rb

@@ -0,0 +1,184 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/registry"
+
+describe Vagrant::Config::Loader do
+  include_context "unit"
+
+  # This is the current version of configuration for the tests.
+  let(:current_version) { version_order.last }
+
+  # This is just a dummy implementation of a configuraiton loader which
+  # simply acts on hashes.
+  let(:test_loader) do
+    Class.new(Vagrant::Config::VersionBase) do
+      def self.init
+        {}
+      end
+
+      def self.load(proc)
+        init.tap do |obj|
+          proc.call(obj)
+        end
+      end
+
+      def self.merge(old, new)
+        old.merge(new)
+      end
+    end
+  end
+
+  let(:versions) do
+    Vagrant::Registry.new.tap do |r|
+      r.register("1") { test_loader }
+    end
+  end
+
+  let(:version_order) { ["1"] }
+
+  let(:instance) { described_class.new(versions, version_order) }
+
+  describe "basic loading" do
+    it "should ignore non-existent load order keys" do
+      instance.load([:foo])
+    end
+
+    it "should load and return the configuration" do
+      proc = Proc.new do |config|
+        config[:foo] = "yep"
+      end
+
+      instance.set(:proc, [[current_version, proc]])
+      config, warnings, errors = instance.load([:proc])
+
+      config[:foo].should == "yep"
+      warnings.should == []
+      errors.should == []
+    end
+  end
+
+  describe "finalization" do
+    it "should finalize the configuration" do
+      # Create the finalize method on our loader
+      def test_loader.finalize(obj)
+        obj[:finalized] = true
+        obj
+      end
+
+      # Basic configuration proc
+      proc = lambda do |config|
+        config[:foo] = "yep"
+      end
+
+      # Run the actual configuration and assert that we get the proper result
+      instance.set(:proc, [[current_version, proc]])
+      config, _ = instance.load([:proc])
+      config[:foo].should == "yep"
+      config[:finalized].should == true
+    end
+  end
+
+  describe "upgrading" do
+    it "should do an upgrade to the latest version" do
+      test_loader_v2 = Class.new(test_loader) do
+        def self.upgrade(old)
+          new = old.dup
+          new[:v2] = true
+
+          [new, [], []]
+        end
+      end
+
+      versions.register("2") { test_loader_v2 }
+      version_order << "2"
+
+      # Load a version 1 proc, and verify it is upgraded to version 2
+      proc = lambda { |config| config[:foo] = "yep" }
+      instance.set(:proc, [["1", proc]])
+      config, _ = instance.load([:proc])
+      config[:foo].should == "yep"
+      config[:v2].should == true
+    end
+
+    it "should keep track of warnings and errors" do
+      test_loader_v2 = Class.new(test_loader) do
+        def self.upgrade(old)
+          new = old.dup
+          new[:v2] = true
+
+          [new, ["foo!"], ["bar!"]]
+        end
+      end
+
+      versions.register("2") { test_loader_v2 }
+      version_order << "2"
+
+      # Load a version 1 proc, and verify it is upgraded to version 2
+      proc = lambda { |config| config[:foo] = "yep" }
+      instance.set(:proc, [["1", proc]])
+      config, warnings, errors = instance.load([:proc])
+      config[:foo].should == "yep"
+      config[:v2].should == true
+      warnings.should == ["foo!"]
+      errors.should == ["bar!"]
+    end
+  end
+
+  describe "loading edge cases" do
+    it "should only run the same proc once" do
+      count = 0
+      proc = Proc.new do |config|
+        config[:foo] = "yep"
+        count += 1
+      end
+
+      instance.set(:proc, [[current_version, proc]])
+
+      5.times do
+        result, _ = instance.load([:proc])
+
+        # Verify the config result
+        result[:foo].should == "yep"
+
+        # Verify the count is only one
+        count.should == 1
+      end
+    end
+
+    it "should only load configuration files once" do
+      $_config_data = 0
+
+      # We test both setting a file multiple times as well as multiple
+      # loads, since both should not cache the data.
+      file = temporary_file("$_config_data += 1")
+      5.times { instance.set(:file, file) }
+      5.times { instance.load([:file]) }
+
+      $_config_data.should == 1
+    end
+
+    it "should not clear the cache if setting to the same value multiple times" do
+      $_config_data = 0
+
+      file = temporary_file("$_config_data += 1")
+
+      instance.set(:proc, file)
+      5.times { instance.load([:proc]) }
+
+      instance.set(:proc, file)
+      5.times { instance.load([:proc]) }
+
+      $_config_data.should == 1
+    end
+
+    it "should raise proper error if there is a syntax error in a Vagrantfile" do
+      expect { instance.set(:file, temporary_file("Vagrant:^Config")) }.
+        to raise_exception(Vagrant::Errors::VagrantfileSyntaxError)
+    end
+
+    it "should raise a proper error if there is a problem with the Vagrantfile" do
+      expect { instance.set(:file, temporary_file("foo")) }.
+        to raise_exception(Vagrant::Errors::VagrantfileLoadError)
+    end
+  end
+end

data/vendor/vagrant/test/unit/vagrant/config/v1/dummy_config_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Config::V1::DummyConfig do
+  it "should allow attribute setting" do
+    expect { subject.foo = :bar }.
+      to_not raise_error
+  end
+
+  it "should allow method calls that return more DummyConfigs" do
+    subject.foo.should be_kind_of(described_class)
+  end
+
+  it "should allow hash access" do
+    expect { subject[:foo] }.
+      to_not raise_error
+
+    subject[:foo].should be_kind_of(described_class)
+  end
+
+  it "should allow setting hash values" do
+    expect { subject[:foo] = :bar }.
+      to_not raise_error
+  end
+end

data/vendor/vagrant/test/unit/vagrant/config/v1/loader_test.rb

@@ -0,0 +1,145 @@
+require "ostruct"
+
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Config::V1::Loader do
+  include_context "unit"
+
+  before(:each) do
+    # Force the V1 loader to believe that we are in V1
+    stub_const("Vagrant::Config::CURRENT_VERSION", "1")
+  end
+
+  describe "empty" do
+    it "returns an empty configuration object" do
+      result = described_class.init
+      result.should be_kind_of(Vagrant::Config::V1::Root)
+    end
+
+    it "returns an object with all configuration keys loaded if V1" do
+      # Make sure we're version 1
+      stub_const("Vagrant::Config::CURRENT_VERSION", "1")
+
+      # Register some config classes.
+      register_plugin("1") do |p|
+        p.config("foo") { OpenStruct }
+        p.config("bar", true) { OpenStruct }
+      end
+
+      # Test that we have all keys
+      result = described_class.init
+      result.foo.should be_kind_of(OpenStruct)
+      result.bar.should be_kind_of(OpenStruct)
+    end
+
+    it "returns only upgradable config objects if not V1" do
+      # Make sure we're NOT version 1
+      stub_const("Vagrant::Config::CURRENT_VERSION", "2")
+
+      # Register some config classes.
+      register_plugin("1") do |p|
+        p.config("foo") { OpenStruct }
+        p.config("bar", true) { OpenStruct }
+      end
+
+      # Test that we have all keys
+      result = described_class.init
+      result.bar.should be_kind_of(OpenStruct)
+    end
+  end
+
+  describe "finalizing" do
+    it "should call `#finalize` on the configuration object" do
+      # Register a plugin for our test
+      register_plugin("1") do |plugin|
+        plugin.config "foo" do
+          Class.new do
+            attr_accessor :bar
+
+            def finalize!
+              @bar = "finalized"
+            end
+          end
+        end
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      config.foo.bar.should == "value"
+
+      # Finalize it
+      described_class.finalize(config)
+      config.foo.bar.should == "finalized"
+    end
+  end
+
+  describe "loading" do
+    it "should configure with all plugin config keys loaded" do
+      # Register a plugin for our test
+      register_plugin("1") do |plugin|
+        plugin.config("foo") { OpenStruct }
+      end
+
+      # Create the proc we're testing
+      config_proc = Proc.new do |config|
+        config.foo.bar = "value"
+      end
+
+      # Test that it works properly
+      config = described_class.load(config_proc)
+      config.foo.bar.should == "value"
+    end
+  end
+
+  describe "merging" do
+    it "should merge available configuration keys" do
+      old = Vagrant::Config::V1::Root.new({ :foo => Object })
+      new = Vagrant::Config::V1::Root.new({ :bar => Object })
+      result = described_class.merge(old, new)
+      result.foo.should be_kind_of(Object)
+      result.bar.should be_kind_of(Object)
+    end
+
+    it "should merge instantiated objects" do
+      config_class = Class.new do
+        attr_accessor :value
+      end
+
+      old = Vagrant::Config::V1::Root.new({ :foo => config_class })
+      old.foo.value = "old"
+
+      new = Vagrant::Config::V1::Root.new({ :bar => config_class })
+      new.bar.value = "new"
+
+      result = described_class.merge(old, new)
+      result.foo.value.should == "old"
+      result.bar.value.should == "new"
+    end
+
+    it "should merge conflicting classes by calling `merge`" do
+      config_class = Class.new do
+        attr_accessor :value
+
+        def merge(new)
+          result       = self.class.new
+          result.value = @value + new.value
+          result
+        end
+      end
+
+      old = Vagrant::Config::V1::Root.new({ :foo => config_class })
+      old.foo.value = 10
+
+      new = Vagrant::Config::V1::Root.new({ :foo => config_class })
+      new.foo.value = 15
+
+      result = described_class.merge(old, new)
+      result.foo.value.should == 25
+    end
+  end
+end