vagrant-lxc 0.0.1

data/vendor/vagrant/test/unit/vagrant/action/builtin/lock_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path("../../../../base", __FILE__)
+
+describe Vagrant::Action::Builtin::Lock do
+  let(:app) { lambda { |env| } }
+  let(:env) { {} }
+  let(:lock_path) do
+    @__lock_path = Tempfile.new("vagrant-test-lock")
+    @__lock_path.path.to_s
+  end
+
+  let(:options) do
+    {
+      :exception => Class.new(StandardError),
+      :path      => lock_path
+    }
+  end
+
+  it "should require a path" do
+    expect { described_class.new(app, env) }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :path => "foo") }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :exception => "foo") }.
+      to raise_error(ArgumentError)
+
+    expect { described_class.new(app, env, :path => "bar", :exception => "foo") }.
+      to_not raise_error
+  end
+
+  it "should allow the path to be a proc" do
+    inner_acquire = true
+    app = lambda do |env|
+      File.open(lock_path, "w+") do |f|
+        inner_acquire = f.flock(File::LOCK_EX | File::LOCK_NB)
+      end
+    end
+
+    options[:path] = lambda { |env| lock_path }
+
+    instance = described_class.new(app, env, options)
+    instance.call(env)
+
+    inner_acquire.should == false
+  end
+
+  it "should allow the exception to be a proc" do
+    exception = options[:exception]
+    options[:exception] = lambda { |env| exception }
+
+    File.open(lock_path, "w+") do |f|
+      # Acquire lock
+      f.flock(File::LOCK_EX | File::LOCK_NB).should == 0
+
+      # Test!
+      instance = described_class.new(app, env, options)
+      expect { instance.call(env) }.
+        to raise_error(exception)
+    end
+  end
+
+  it "should call the middleware with the lock held" do
+    inner_acquire = true
+    app = lambda do |env|
+      File.open(lock_path, "w+") do |f|
+        inner_acquire = f.flock(File::LOCK_EX | File::LOCK_NB)
+      end
+    end
+
+    instance = described_class.new(app, env, options)
+    instance.call(env)
+
+    inner_acquire.should == false
+  end
+
+  it "should raise an exception if the lock is already held" do
+    File.open(lock_path, "w+") do |f|
+      # Acquire lock
+      f.flock(File::LOCK_EX | File::LOCK_NB).should == 0
+
+      # Test!
+      instance = described_class.new(app, env, options)
+      expect { instance.call(env) }.
+        to raise_error(options[:exception])
+    end
+  end
+
+  it "should allow nesting locks within the same middleware sequence" do
+    called = false
+    app = lambda { |env| called = true }
+    inner = described_class.new(app, env, options)
+    outer = described_class.new(inner, env, options)
+    outer.call(env)
+
+    called.should == true
+  end
+end

data/vendor/vagrant/test/unit/vagrant/action/builtin/ssh_exec_test.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../../../base", __FILE__)
+
+require "vagrant/util/ssh"
+
+describe Vagrant::Action::Builtin::SSHExec do
+  let(:app) { lambda { |env| } }
+  let(:env) { { :machine => machine } }
+  let(:machine) do
+    result = double("machine")
+    result.stub(:ssh_info).and_return(machine_ssh_info)
+    result
+  end
+  let(:machine_ssh_info) { {} }
+  let(:ssh_klass) { Vagrant::Util::SSH }
+
+  before(:each) do
+    # Stub the methods so that even if we test incorrectly, no side
+    # effects actually happen.
+    ssh_klass.stub(:check_key_permissions)
+    ssh_klass.stub(:exec)
+  end
+
+  it "should raise an exception if SSH is not ready" do
+    not_ready_machine = double("machine")
+    not_ready_machine.stub(:ssh_info).and_return(nil)
+
+    env[:machine] = not_ready_machine
+    expect { described_class.new(app, env).call(env) }.
+      to raise_error(Vagrant::Errors::SSHNotReady)
+  end
+
+  it "should check key permissions then exec" do
+    machine_ssh_info[:private_key_path] = "/foo"
+
+    ssh_klass.should_receive(:check_key_permissions).
+      with(Pathname.new(machine_ssh_info[:private_key_path])).
+      once.
+      ordered
+
+    ssh_klass.should_receive(:exec).
+      with(machine_ssh_info, nil).
+      once.
+      ordered
+
+    described_class.new(app, env).call(env)
+  end
+
+  it "should exec with the options given in `ssh_opts`" do
+    ssh_opts = { :foo => :bar }
+
+    ssh_klass.should_receive(:exec).
+      with(machine_ssh_info, ssh_opts)
+
+    env[:ssh_opts] = ssh_opts
+    described_class.new(app, env).call(env)
+  end
+end

data/vendor/vagrant/test/unit/vagrant/action/hook_test.rb

@@ -0,0 +1,101 @@
+require File.expand_path("../../../base", __FILE__)
+
+require "vagrant/action/builder"
+require "vagrant/action/hook"
+
+describe Vagrant::Action::Hook do
+  describe "defaults" do
+    its("after_hooks")   { should be_empty }
+    its("before_hooks")  { should be_empty }
+    its("append_hooks")  { should be_empty }
+    its("prepend_hooks") { should be_empty }
+  end
+
+  describe "before hooks" do
+    let(:existing) { "foo" }
+
+    it "should append them" do
+      block = Proc.new {}
+
+      subject.before(existing, 1)
+      subject.before(existing, 2)
+      subject.before(existing, 3, :arg, &block)
+
+      subject.before_hooks[existing].should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "after hooks" do
+    let(:existing) { "foo" }
+
+    it "should append them" do
+      block = Proc.new {}
+
+      subject.after(existing, 1)
+      subject.after(existing, 2)
+      subject.after(existing, 3, :arg, &block)
+
+      subject.after_hooks[existing].should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "append" do
+    it "should make a list" do
+      block = Proc.new {}
+
+      subject.append(1)
+      subject.append(2)
+      subject.append(3, :arg, &block)
+
+      subject.append_hooks.should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "prepend" do
+    it "should make a list" do
+      block = Proc.new {}
+
+      subject.prepend(1)
+      subject.prepend(2)
+      subject.prepend(3, :arg, &block)
+
+      subject.prepend_hooks.should == [
+        [1, [], nil],
+        [2, [], nil],
+        [3, [:arg], block]
+      ]
+    end
+  end
+
+  describe "applying" do
+    let(:builder) { Vagrant::Action::Builder.new }
+
+    it "should build the proper stack" do
+      subject.prepend("1", 2)
+      subject.append("9")
+      subject.after("1", "2")
+      subject.before("9", "8")
+
+      subject.apply(builder)
+
+      builder.stack.should == [
+        ["1", [2], nil],
+        ["2", [], nil],
+        ["8", [], nil],
+        ["9", [], nil]
+      ]
+    end
+  end
+end

data/vendor/vagrant/test/unit/vagrant/action/runner_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Runner do
+  let(:instance) { described_class.new }
+
+  it "should raise an error if an invalid callable is given" do
+    expect { instance.run(7) }.to raise_error(ArgumentError, /must be a callable/)
+  end
+
+  it "should be able to use a Proc as a callable" do
+    callable = Proc.new { raise Exception, "BOOM" }
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should be able to use a Class as a callable" do
+    callable = Class.new do
+      def initialize(app, env)
+      end
+
+      def call(env)
+        raise Exception, "BOOM"
+      end
+    end
+
+    expect { instance.run(callable) }.to raise_error(Exception, "BOOM")
+  end
+
+  it "should return the resulting environment" do
+    callable = lambda do |env|
+      env[:data] = "value"
+
+      # Return nil so we can make sure it isn't using this return value
+      nil
+    end
+
+    result = instance.run(callable)
+    result[:data].should == "value"
+  end
+
+  it "should pass options into hash given to callable" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance.run(callable, "data" => "foo")
+    result.should == "foo"
+  end
+
+  it "should pass global options into the hash" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new("data" => "bar")
+    instance.run(callable)
+    result.should == "bar"
+  end
+
+  it "should yield the block passed to the init method to get lazy loaded globals" do
+    result = nil
+    callable = lambda do |env|
+      result = env["data"]
+    end
+
+    instance = described_class.new { { "data" => "bar" } }
+    instance.run(callable)
+    result.should == "bar"
+  end
+end

data/vendor/vagrant/test/unit/vagrant/action/warden_test.rb

@@ -0,0 +1,92 @@
+require File.expand_path("../../../base", __FILE__)
+
+describe Vagrant::Action::Warden do
+  let(:data) { { :data => [] } }
+  let(:instance) { described_class.new }
+
+  # This returns a proc that can be used with the builder
+  # that simply appends data to an array in the env.
+  def appender_proc(data)
+    Proc.new { |env| env[:data] << data }
+  end
+
+  it "calls the actions like normal" do
+    instance = described_class.new([appender_proc(1), appender_proc(2)], data)
+    instance.call(data)
+
+    data[:data].should == [1, 2]
+  end
+
+  it "starts a recovery sequence when an exception is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] << 1
+      end
+    end
+
+    class ActionTwo
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] << 2
+      end
+    end
+
+    error_proc = Proc.new { raise "ERROR!" }
+
+    data     = { :recover => [] }
+    instance = described_class.new([Action, ActionTwo, error_proc], data)
+
+    # The error should be raised back up
+    expect { instance.call(data) }.
+      to raise_error(RuntimeError)
+
+    # Verify the recovery process goes in reverse order
+    data[:recover].should == [2, 1]
+
+    # Verify that the error is available in the data
+    data["vagrant.error"].should be_kind_of(RuntimeError)
+  end
+
+  it "does not do a recovery sequence if SystemExit is raised" do
+    class Action
+      def initialize(app, env)
+        @app = app
+      end
+
+      def call(env)
+        @app.call(env)
+      end
+
+      def recover(env)
+        env[:recover] = true
+      end
+    end
+
+    # Make a proc that just calls "abort" which raises a
+    # SystemExit exception.
+    error_proc = Proc.new { abort }
+
+    instance = described_class.new([Action, error_proc], data)
+
+    # The SystemExit should come through
+    expect { instance.call(data) }.to raise_error(SystemExit)
+
+    # The recover should not have been called
+    data.has_key?(:recover).should_not be
+  end
+end

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

@@ -0,0 +1,224 @@
+require File.expand_path("../../base", __FILE__)
+
+require "pathname"
+require 'tempfile'
+
+describe Vagrant::BoxCollection do
+  include_context "unit"
+
+  let(:box_class)   { Vagrant::Box }
+  let(:environment) { isolated_environment }
+  let(:instance)    { described_class.new(environment.boxes_dir) }
+
+  it "should tell us the directory it is using" do
+    instance.directory.should == environment.boxes_dir
+  end
+
+  describe "adding" do
+    it "should add a valid box to the system" do
+      box_path = environment.box2_file(:virtualbox)
+
+      # Add the box
+      box = instance.add(box_path, "foo", :virtualbox)
+      box.should be_kind_of(box_class)
+      box.name.should == "foo"
+      box.provider.should == :virtualbox
+
+      # Verify we can find it as well
+      box = instance.find("foo", :virtualbox)
+      box.should_not be_nil
+    end
+
+    it "should add a box without specifying a provider" do
+      box_path = environment.box2_file(:vmware)
+
+      # Add the box
+      box = instance.add(box_path, "foo")
+      box.should be_kind_of(box_class)
+      box.name.should == "foo"
+      box.provider.should == :vmware
+    end
+
+    it "should add a V1 box" do
+      # Create a V1 box.
+      box_path = environment.box1_file
+
+      # Add the box
+      box = instance.add(box_path, "foo")
+      box.should be_kind_of(box_class)
+      box.name.should == "foo"
+      box.provider.should == :virtualbox
+    end
+
+    it "should raise an exception if the box already exists" do
+      prev_box_name = "foo"
+      prev_box_provider = :virtualbox
+
+      # Create the box we're adding
+      environment.box2(prev_box_name, prev_box_provider)
+
+      # Attempt to add the box with the same name
+      box_path = environment.box2_file(prev_box_provider)
+      expect { instance.add(box_path, prev_box_name, prev_box_provider) }.
+        to raise_error(Vagrant::Errors::BoxAlreadyExists)
+    end
+
+    it "should raise an exception if the box already exists and no provider is given" do
+      # Create some box file
+      box_name = "foo"
+      box_path = environment.box2_file(:vmware)
+
+      # Add it once, successfully
+      expect { instance.add(box_path, box_name) }.to_not raise_error
+
+      # Add it again, and fail!
+      expect { instance.add(box_path, box_name) }.
+        to raise_error(Vagrant::Errors::BoxAlreadyExists)
+    end
+
+    it "should raise an exception if you're attempting to add a box that exists as a V1 box" do
+      prev_box_name = "foo"
+
+      # Create the V1 box
+      environment.box1(prev_box_name)
+
+      # Attempt to add some V2 box with the same name
+      box_path = environment.box2_file(:vmware)
+      expect { instance.add(box_path, prev_box_name) }.
+        to raise_error(Vagrant::Errors::BoxUpgradeRequired)
+    end
+
+    it "should raise an exception and not add the box if the provider doesn't match" do
+      box_name      = "foo"
+      good_provider = :virtualbox
+      bad_provider  = :vmware
+
+      # Create a VirtualBox box file
+      box_path = environment.box2_file(good_provider)
+
+      # Add the box but with an invalid provider, verify we get the proper
+      # error.
+      expect { instance.add(box_path, box_name, bad_provider) }.
+        to raise_error(Vagrant::Errors::BoxProviderDoesntMatch)
+
+      # Verify the box doesn't exist
+      instance.find(box_name, bad_provider).should be_nil
+    end
+
+    it "should raise an exception if you add an invalid box file" do
+      # Tar Header information
+      CHECKSUM_OFFSET = 148
+      CHECKSUM_LENGTH = 8
+
+      Tempfile.new(['vagrant_testing', '.tar']) do |f|
+        # Corrupt the tar by writing over the checksum field
+        f.seek(CHECKSUM_OFFSET)
+        f.write("\0"*CHECKSUM_LENGTH)
+        f.close
+
+        expect { instance.add(path, "foo", :virtualbox) }.
+          to raise_error(Vagrant::Errors::BoxUnpackageFailure)
+      end
+    end
+  end
+
+  describe "listing all" do
+    it "should return an empty array when no boxes are there" do
+      instance.all.should == []
+    end
+
+    it "should return the boxes and their providers" do
+      # Create some boxes
+      environment.box2("foo", :virtualbox)
+      environment.box2("foo", :vmware)
+      environment.box2("bar", :ec2)
+
+      # Verify some output
+      results = instance.all
+      results.length.should == 3
+      results.include?(["foo", :virtualbox]).should be
+      results.include?(["foo", :vmware]).should be
+      results.include?(["bar", :ec2]).should be
+    end
+
+    it "should return V1 boxes as well" do
+      # Create some boxes, including a V1 box
+      environment.box1("bar")
+      environment.box2("foo", :vmware)
+
+      # Verify some output
+      results = instance.all.sort
+      results.should == [["bar", :virtualbox, :v1], ["foo", :vmware]]
+    end
+
+    it 'does not raise an exception when a file appears in the boxes dir' do
+      Tempfile.new('a_file', environment.boxes_dir)
+      expect { instance.all }.to_not raise_error
+    end
+  end
+
+  describe "finding" do
+    it "should return nil if the box does not exist" do
+      instance.find("foo", :i_dont_exist).should be_nil
+    end
+
+    it "should return a box if the box does exist" do
+      # Create the "box"
+      environment.box2("foo", :virtualbox)
+
+      # Actual test
+      result = instance.find("foo", :virtualbox)
+      result.should_not be_nil
+      result.should be_kind_of(box_class)
+      result.name.should == "foo"
+    end
+
+    it "should throw an exception if it is a v1 box" do
+      # Create a V1 box
+      environment.box1("foo")
+
+      # Test!
+      expect { instance.find("foo", :virtualbox) }.
+        to raise_error(Vagrant::Errors::BoxUpgradeRequired)
+    end
+
+    it "should return nil if there is a V1 box but we're looking for another provider" do
+      # Create a V1 box
+      environment.box1("foo")
+
+      # Test
+      instance.find("foo", :another_provider).should be_nil
+    end
+  end
+
+  describe "upgrading" do
+    it "should upgrade a V1 box to V2" do
+      # Create a V1 box
+      environment.box1("foo")
+
+      # Verify that only a V1 box exists
+      expect { instance.find("foo", :virtualbox) }.
+        to raise_error(Vagrant::Errors::BoxUpgradeRequired)
+
+      # Upgrade the box
+      instance.upgrade("foo").should be
+
+      # Verify the box exists
+      box = instance.find("foo", :virtualbox)
+      box.should_not be_nil
+      box.name.should == "foo"
+    end
+
+    it "should raise a BoxNotFound exception if a non-existent box is upgraded" do
+      expect { instance.upgrade("i-dont-exist") }.
+        to raise_error(Vagrant::Errors::BoxNotFound)
+    end
+
+    it "should return true if we try to upgrade a V2 box" do
+      # Create a V2 box
+      environment.box2("foo", :vmware)
+
+      instance.upgrade("foo").should be
+    end
+  end
+end