vagrant 0.8.10 → 0.9.0

data/test/unit/vagrant/config_test.rb

@@ -1,162 +1,27 @@
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class ConfigTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Config
-  end
-
-  context "with the class" do
-    should "allow access to the last proc" do
-      foo = mock("object")
-      foo.expects(:call).once
-
-      @klass.run { |config| foo.call }
-      value = @klass.last_proc.first
-      assert value.is_a?(Proc)
-      value.call(nil)
-
-      assert @klass.last_proc.nil?
-    end
-  end
-
-  context "with an instance" do
-    setup do
-      @instance = @klass.new
-    end
-
-    should "load the config files in the given order" do
-      names = %w{alpha beta gamma}
-
-      @instance.load_order = [:alpha, :beta]
-
-      names.each do |name|
-        vagrantfile(vagrant_box(name), "config.vm.box = '#{name}'")
-        @instance.set(name.to_sym, vagrant_box(name).join("Vagrantfile"))
-      end
-
-      config = @instance.load(nil)
-      assert_equal "beta", config.vm.box
-    end
-
-    should "load the config as procs" do
-      @instance.set(:proc, Proc.new { |config| config.vm.box = "proc" })
-      @instance.load_order = [:proc]
-      config = @instance.load(nil)
-
-      assert_equal "proc", config.vm.box
-    end
-
-    should "load an array of procs" do
-      @instance.set(:proc, [Proc.new { |config| config.vm.box = "proc" },
-                            Proc.new { |config| config.vm.box = "proc2" }])
-      @instance.load_order = [:proc]
-      config = @instance.load(nil)
-
-      assert_equal "proc2", config.vm.box
-    end
-
-    should "not care if a file doesn't exist" do
-      @instance.load_order = [:foo]
-      assert_nothing_raised { @instance.set(:foo, "i/dont/exist") }
-      assert_nothing_raised { @instance.load(nil) }
-    end
-
-    should "not reload a file" do
-      foo_path = vagrant_box("foo").join("Vagrantfile")
-
-      vagrantfile(vagrant_box("foo"))
-      @instance.set(:foo, foo_path)
-
-      # Nothing should be raised in this case because the file isn't reloaded
-      vagrantfile(vagrant_box("foo"), "^%&8318")
-      assert_nothing_raised { @instance.set(:foo, foo_path) }
-    end
-
-    should "raise an exception if there is a syntax error in a file" do
-      vagrantfile(vagrant_box("foo"), "^%&8318")
-
-      assert_raises(Vagrant::Errors::VagrantfileSyntaxError) {
-        @instance.set(:foo, vagrant_box("foo").join("Vagrantfile"))
-      }
+describe Vagrant::Config do
+  it "should not execute the proc on configuration" do
+    described_class.run do
+      raise Exception, "Failure."
     end
   end
 
-  context "top config class" do
-    setup do
-      @configures_list = {}
-      @klass::Top.stubs(:configures_list).returns(@configures_list)
-    end
-
-    context "adding configure keys" do
-      setup do
-        @key = "top_config_foo"
-        @config_klass = mock("klass")
-      end
+  it "should capture configuration procs" do
+    receiver = double()
 
-      should "add key and klass to configures list" do
-        @klass::Top.configures(@key, @config_klass)
-        assert_equal @config_klass, @configures_list[@key]
+    procs = described_class.capture_configures do
+      described_class.run do
+        receiver.hello!
       end
     end
 
-    context "configuration keys on instance" do
-      setup do
-        @configures_list.clear
-      end
-
-      should "initialize each configurer and set it to its key" do
-        env = mock('env')
-
-        5.times do |i|
-          key = "key#{i}"
-          klass = mock("klass#{i}")
-          instance = mock("instance#{i}")
-          instance.expects(:top=).with() do |top|
-            assert top.is_a?(@klass::Top)
-            true
-          end
-          klass.expects(:new).returns(instance)
-          @configures_list[key] = klass
-        end
+    # Verify the structure of the result
+    procs.should be_kind_of(Array)
+    procs.length.should == 1
 
-        @klass::Top.new(env)
-      end
-
-      should "allow reading via methods" do
-        key = "my_foo_bar_key"
-        klass = mock("klass")
-        instance = mock("instance")
-        instance.stubs(:top=)
-        klass.expects(:new).returns(instance)
-        @klass::Top.configures(key, klass)
-
-        config = @klass::Top.new
-        assert_equal instance, config.send(key)
-      end
-    end
-
-    context "validation" do
-      should "do nothing if no errors are added" do
-        valid_class = Class.new(@klass::Base)
-        @klass::Top.configures(:subconfig, valid_class)
-        instance = @klass::Top.new
-        assert_nothing_raised { instance.validate! }
-      end
-
-      should "raise an exception if there are errors" do
-        invalid_class = Class.new(@klass::Base) do
-          def validate(errors)
-            errors.add("vagrant.test.errors.test_key")
-          end
-        end
-
-        @klass::Top.configures(:subconfig, invalid_class)
-        instance = @klass::Top.new
-
-        assert_raises(Vagrant::Errors::ConfigValidationFailed) {
-          instance.validate!
-        }
-      end
-    end
+    # Verify that the proper proc was captured
+    receiver.should_receive(:hello!).once
+    procs[0].call
   end
 end

data/test/unit/vagrant/data_store_test.rb

@@ -1,85 +1,67 @@
-require "fileutils"
-require "test_helper"
+require File.expand_path("../../base", __FILE__)
 
-class DataStoreTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::DataStore
-    @initial_data = { "foo" => "bar" }
-    @db_file = File.join(tmp_path, "data_store_test")
-    File.open(@db_file, "w") { |f| f.write(@initial_data.to_json) }
+require 'pathname'
 
-    @instance = @klass.new(@db_file)
-  end
+describe Vagrant::DataStore do
+  include_context "unit"
 
-  teardown do
-    File.delete(@db_file) if File.exist?(@db_file)
-  end
+  let(:db_file) do
+    # We create a tempfile and force an explicit close/unlink
+    # but save the path so that we can re-use it multiple times
+    temp = Tempfile.new("vagrant")
+    result = Pathname.new(temp.path)
+    temp.close
+    temp.unlink
 
-  should "raise an exception if the db file is a directory" do
-    file = tmp_path.join("data_store_folder_test")
-    FileUtils.mkdir_p(file)
-    assert_raises (Vagrant::Errors::DotfileIsDirectory) {
-      @klass.new(file)
-    }
+    result
   end
 
-  should "initialize just fine if the db file contains invalid data" do
-    file = tmp_path.join("data_store_empty_test")
-    File.open(file, "w") { |f| f.write("") }
+  let(:instance)    { described_class.new(db_file) }
 
-    instance = @klass.new(file)
-    assert instance.length == 0
-  end
+  it "initializes a new DB file" do
+    instance[:data] = true
+    instance.commit
+    instance[:data].should == true
 
-  should "be a hash with indifferent access" do
-    assert @instance.is_a?(Vagrant::Util::HashWithIndifferentAccess)
+    test = described_class.new(db_file)
+    test[:data].should == true
   end
 
-  should "just be an empty hash if file doesn't exist" do
-    assert @klass.new("NEvERNENVENRNE").empty?
+  it "initializes empty if the file contains invalid data" do
+    db_file.open("w+") { |f| f.write("NOPE!") }
+    described_class.new(db_file).should be_empty
   end
 
-  should "read the data" do
-    assert_equal @initial_data["foo"], @instance[:foo]
+  it "initializes empty if the file doesn't exist" do
+    described_class.new("NOPENOPENOPENOPENPEPEPEPE").should be_empty
   end
 
-  should "read the data by stringifying keys" do
-    @instance[:bar] = { "baz" => "yay" }
-    @instance.commit
-    @instance = @klass.new(@db_file)
-    assert_equal "yay", @instance[:bar]["baz"]
-  end
+  it "raises an error if the path given is a directory" do
+    db_file.delete if db_file.exist?
+    db_file.mkdir
 
-  should "write the data, but not save it right away" do
-    @instance[:foo] = "changed"
-    assert_equal "changed", @instance[:foo]
-    assert_equal @initial_data["foo"], @klass.new(@db_file)["foo"]
+    expect { described_class.new(db_file) }.
+      to raise_error(Vagrant::Errors::DotfileIsDirectory)
   end
 
-  should "write the data if commit is called" do
-    @instance[:foo] = "changed"
-    @instance.commit
+  it "cleans nil and empties when committing" do
+    instance[:data] = { :bar => nil }
+    instance[:another] = {}
+    instance.commit
 
-    assert_equal "changed", @klass.new(@db_file)[:foo]
+    # The instance is now empty because the data was nil
+    instance.should be_empty
   end
 
-  should "delete the data store file if the hash is empty" do
-    @instance[:foo] = :bar
-    @instance.commit
-    assert File.exist?(@db_file)
-
-    @instance.clear
-    assert @instance.empty?
-    @instance.commit
-    assert !File.exist?(@db_file)
-  end
+  it "deletes the data file if the store is empty when saving" do
+    instance[:data] = true
+    instance.commit
 
-  should "clean nil and empties if commit is called" do
-    @instance[:foo] = { :bar => nil }
-    @instance[:bar] = {}
-    @instance.commit
+    another = described_class.new(db_file)
+    another[:data] = nil
+    another.commit
 
-    assert !@instance.has_key?(:foo)
-    assert !@instance.has_key?(:bar)
+    # The file should no longer exist
+    db_file.should_not be_exist
   end
 end

data/test/unit/vagrant/downloaders/base_test.rb

@@ -1,28 +1,18 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class BaseDownloaderTest < Test::Unit::TestCase
-  should "include the util class so subclasses have access to it" do
-    assert Vagrant::Downloaders::Base.include?(Vagrant::Util)
-  end
+describe Vagrant::Downloaders::Base do
+  let(:ui) { double("ui") }
+  let(:instance) { described_class.new(ui) }
 
-  context "base instance" do
-    setup do
-      @env = vagrant_env
-      @base = Vagrant::Downloaders::Base.new(@env)
-    end
+  it "should not match anything by default" do
+    described_class.match?("foo").should_not be
+  end
 
-    should "implement prepare which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:prepare)
-        @base.prepare("source")
-      end
-    end
+  it "should implement `prepare`" do
+    instance.prepare("foo").should be_nil
+  end
 
-    should "implement download! which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:download!)
-        @base.download!("source", "destination")
-      end
-    end
+  it "should implement `download!`" do
+    instance.download!("foo", "bar").should be_nil
   end
 end

data/test/unit/vagrant/downloaders/file_test.rb

@@ -1,48 +1,75 @@
-require "test_helper"
+require File.expand_path("../../../base", __FILE__)
 
-class FileDownloaderTest < Test::Unit::TestCase
-  setup do
-    @downloader, @tempfile = vagrant_mock_downloader(Vagrant::Downloaders::File)
-    @uri = "foo.box"
-  end
+require "tempfile"
 
-  context "preparing" do
-    should "raise an exception if the file does not exist" do
-      File.expects(:file?).with(@uri).returns(false)
+describe Vagrant::Downloaders::File do
+  let(:ui) { double("ui") }
+  let(:instance) { described_class.new(ui) }
 
-      assert_raises(Vagrant::Errors::DownloaderFileDoesntExist) {
-        @downloader.prepare(@uri)
-      }
+  describe "matching" do
+    it "should match an existing file" do
+      described_class.match?(__FILE__).should be
     end
-  end
 
-  context "downloading" do
-    setup do
-      clean_paths
+    it "should not match non-existent files" do
+      described_class.match?(File.join(__FILE__, "nowaywaywaywayayway")).should_not be
     end
 
-    should "cp the file" do
-      uri = tmp_path.join("foo_source")
-      dest = tmp_path.join("foo_dest")
+    it "should match files where the path needs to be expanded" do
+      old_home = ENV["HOME"]
+      begin
+        # Create a temporary file
+        temp = Tempfile.new("vagrant")
 
-      # Create the source file, then "download" it
-      File.open(uri, "w+") { |f| f.write("FOO") }
-      File.open(dest, "w+") do |dest_file|
-        @downloader.download!(uri, dest_file)
+        # Set our home directory to be this directory so we can use
+        # "~" paths
+        ENV["HOME"] = File.dirname(temp.path)
+
+        # Test that we can find the temp file
+        described_class.match?("~/#{File.basename(temp.path)}").should be
+      ensure
+        ENV["HOME"] = old_home
       end
+    end
+  end
+
+  describe "preparing" do
+    it "should raise an exception if the file does not exist" do
+      path = File.join(__FILE__, "nopenopenope")
+      File.exist?(path).should_not be
+
+      expect { instance.prepare(path) }.to raise_error(Vagrant::Errors::DownloaderFileDoesntExist)
+    end
+
+    it "should raise an exception if the file is a directory" do
+      path = File.dirname(__FILE__)
+      File.should be_directory(path)
+
+      expect { instance.prepare(path) }.to raise_error(Vagrant::Errors::DownloaderFileDoesntExist)
+    end
+
+    it "should find files that use shell expansions" do
+      old_home = ENV["HOME"]
+      begin
+        # Create a temporary file
+        temp = Tempfile.new("vagrant")
+
+        # Set our home directory to be this directory so we can use
+        # "~" paths
+        ENV["HOME"] = File.dirname(temp.path)
 
-      # Finally, verify the destination file was properly created
-      assert File.file?(dest)
-      File.open(dest) do |f|
-        assert_equal "FOO", f.read
+        # Test that we can find the temp file
+        expect { instance.prepare("~/#{File.basename(temp.path)}") }.
+          to_not raise_error
+      ensure
+        ENV["HOME"] = old_home
       end
     end
   end
 
-  context "matching a uri" do
-    should "return true if the File exists on the file system" do
-      File.expects(:exists?).with('foo').returns(true)
-      assert Vagrant::Downloaders::File.match?('foo')
+  describe "downloading" do
+    it "should copy the source to the destination" do
+      pending "setup paths"
     end
   end
 end