tnargav 1.2.2

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

@@ -0,0 +1,120 @@
+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
+
+    it "should not prepend or append if disabled" do
+      builder.use("3")
+      builder.use("8")
+
+      subject.prepend("1", 2)
+      subject.append("9")
+      subject.after("3", "4")
+      subject.before("8", "7")
+
+      subject.apply(builder, no_prepend_or_append: true)
+
+      builder.stack.should == [
+        ["3", [], nil],
+        ["4", [], nil],
+        ["7", [], nil],
+        ["8", [], nil]
+      ]
+    end
+  end
+end

data/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/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/test/unit/vagrant/batch_action_test.rb

@@ -0,0 +1,36 @@
+require 'thread'
+
+require File.expand_path("../../base", __FILE__)
+
+describe Vagrant::BatchAction do
+  let(:called_actions) { [] }
+  let!(:lock) { Mutex.new }
+  let(:provider_name) { "test" }
+  let(:provider_options) { {} }
+
+  def new_machine(options)
+    double("machine").tap do |m|
+      m.stub(:provider_name => provider_name)
+      m.stub(:provider_options => options)
+      m.stub(:action) do |action, opts|
+        lock.synchronize do
+          called_actions << [m, action, opts]
+        end
+      end
+    end
+  end
+
+  describe "#run" do
+    let(:machine) { new_machine(provider_options) }
+    let(:machine2) { new_machine(provider_options) }
+
+    it "should run the actions on the machines in order" do
+      subject.action(machine, "up")
+      subject.action(machine2, "destroy")
+      subject.run
+
+      called_actions.include?([machine, "up", nil]).should be
+      called_actions.include?([machine2, "destroy", nil]).should be
+    end
+  end
+end

data/test/unit/vagrant/box_collection_test.rb

@@ -0,0 +1,237 @@
+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 replace the box if force is specified" do
+      prev_box_name = "foo"
+      prev_box_provider = :vmware
+
+      # Setup the environment with the box pre-added
+      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, metadata: { "replaced" => "yes" })
+      box = instance.add(box_path, prev_box_name, nil, true)
+      box.metadata["replaced"].should == "yes"
+    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

data/test/unit/vagrant/box_test.rb

@@ -0,0 +1,122 @@
+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) }
+
+  subject { 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
+
+  context "without a metadata file" do
+    before :each do
+      directory.join("metadata.json").delete
+    end
+
+    it "should raise an exception" do
+      expect { subject }.
+        to raise_error(Vagrant::Errors::BoxMetadataFileNotFound)
+    end
+  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/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