vagrantup 1.0.7 → 1.1.0

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

@@ -1,13 +1,7 @@
 require File.expand_path("../../../base", __FILE__)
 
 describe Vagrant::Action::Runner do
-  let(:registry) do
-    d = double("registry")
-    d.stub(:get)
-    d
-  end
-
-  let(:instance) { described_class.new(registry) }
+  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/)
@@ -31,6 +25,18 @@ describe Vagrant::Action::Runner do
     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|
@@ -47,7 +53,7 @@ describe Vagrant::Action::Runner do
       result = env["data"]
     end
 
-    instance = described_class.new(registry, "data" => "bar")
+    instance = described_class.new("data" => "bar")
     instance.run(callable)
     result.should == "bar"
   end
@@ -58,7 +64,7 @@ describe Vagrant::Action::Runner do
       result = env["data"]
     end
 
-    instance = described_class.new(registry) { { "data" => "bar" } }
+    instance = described_class.new { { "data" => "bar" } }
     instance.run(callable)
     result.should == "bar"
   end

data/test/unit/vagrant/box_collection_test.rb

@@ -1,56 +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(:action_runner) { double("action runner") }
-  let(:instance)    { described_class.new(environment.boxes_dir, action_runner) }
-
-  it "should list all available boxes" do
-    # No boxes yet.
-    instance.length.should == 0
-
-    # Add some boxes to the environment and try again
-    environment.box("foo")
-    environment.box("bar")
-    instance.reload!
-    instance.length.should == 2
+  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 it can't find the box" do
-      instance.find("foo").should be_nil
+    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 instance for any boxes it does find" do
-      environment.box("foo")
-      result = instance.find("foo")
-      result.should be_kind_of(Vagrant::Box)
+    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
-  end
 
-  it "should throw an error if the box already exists when adding" do
-    environment.box("foo")
-    expect { instance.add("foo", "bar") }.to raise_error(Vagrant::Errors::BoxAlreadyExists)
+    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
 
-  it "should add the box" do
-    name = "foo"
-    url  = "bar"
-
-    # Test the invocation of the action runner with the proper name
-    # and parameters. We leave the testing of the actual stack to
-    # acceptance tests, and individual pieces to unit tests of each
-    # step.
-    options = {
-      :box_name => name,
-      :box_url => url,
-      :box_directory => instance.directory.join(name)
-    }
-    action_runner.should_receive(:run).with(:box_add, options)
-
-    instance.add(name, url)
+  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

@@ -1,34 +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(:directory)     { "bar" }
-  let(:action_runner) { double("action_runner") }
-  let(:instance)      { described_class.new(name, directory, action_runner) }
+  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 "can destroy itself" do
-    # Simply test the messages to the action runner
-    options = {
-      :box_name => name,
-      :box_directory => directory
-    }
-    action_runner.should_receive(:run).with(:box_remove, options)
+  it "provides the provider" do
+    instance.provider.should == provider
+  end
 
-    instance.destroy
+  it "provides the directory" do
+    instance.directory.should == directory
   end
 
-  it "can repackage itself" do
-    # Simply test the messages to the action runner
-    options = {
-      :box_name => name,
-      :box_directory => directory
-    }
-    action_runner.should_receive(:run).with(:box_repackage, options)
+  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)
 
-    instance.repackage
+      [c, a, b].sort.should == [a, b, c]
+    end
   end
 end