vagrantup 0.5.2 → 0.5.3

data/test/vagrant/config_test.rb

@@ -0,0 +1,307 @@
+require "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  context "the ssh config" do
+    setup do
+      @env = mock_environment
+      @env.stubs(:root_path).returns("foo")
+    end
+
+    should "expand any path when requesting the value" do
+      result = File.expand_path(@env.config.ssh[:private_key_path], @env.root_path)
+      assert_equal result, @env.config.ssh.private_key_path
+    end
+  end
+
+  context "adding configures" do
+    should "forward the method to the Top class" do
+      key = mock("key")
+      klass = mock("klass")
+      Vagrant::Config::Top.expects(:configures).with(key, klass)
+      Vagrant::Config.configures(key, klass)
+    end
+  end
+
+  context "resetting" do
+    setup do
+      Vagrant::Config.run { |config| }
+      Vagrant::Config.execute!
+    end
+
+    should "return the same config object typically" do
+      config = Vagrant::Config.config
+      assert config.equal?(Vagrant::Config.config)
+    end
+
+    should "create a new object if cleared" do
+      config = Vagrant::Config.config
+      Vagrant::Config.reset!
+      assert !config.equal?(Vagrant::Config.config)
+    end
+
+    should "empty the proc stack" do
+      assert !Vagrant::Config.proc_stack.empty?
+      Vagrant::Config.reset!
+      assert Vagrant::Config.proc_stack.empty?
+    end
+
+    should "reload the config object based on the given environment" do
+      env = mock("env")
+      Vagrant::Config.expects(:config).with(env).once
+      Vagrant::Config.reset!(env)
+    end
+  end
+
+  context "initializing" do
+    setup do
+      Vagrant::Config.reset!
+    end
+
+    should "add the given block to the proc stack" do
+      proc = Proc.new {}
+      Vagrant::Config.run(&proc)
+      assert_equal [proc], Vagrant::Config.proc_stack
+    end
+
+    should "run the proc stack with the config when execute is called" do
+      Vagrant::Config.expects(:run_procs!).with(Vagrant::Config.config).once
+      Vagrant::Config.execute!
+    end
+
+    should "not be loaded, initially" do
+      assert !Vagrant::Config.config.loaded?
+    end
+
+    should "be loaded after running" do
+      Vagrant::Config.run {}
+      Vagrant::Config.execute!
+      assert Vagrant::Config.config.loaded?
+    end
+
+    should "return the configuration on execute!" do
+      Vagrant::Config.run {}
+      result = Vagrant::Config.execute!
+      assert result.is_a?(Vagrant::Config::Top)
+    end
+
+    should "use given configuration object if given" do
+      fake_env = mock("env")
+      config = Vagrant::Config::Top.new(fake_env)
+      result = Vagrant::Config.execute!(config)
+      assert_equal config.env, result.env
+    end
+  end
+
+  context "base class" do
+    setup do
+      @base = Vagrant::Config::Base.new
+    end
+
+    should "forward [] access to methods" do
+      @base.expects(:foo).once
+      @base[:foo]
+    end
+
+    should "return a hash of instance variables" do
+      data = { :foo => "bar", :bar => "baz" }
+
+      data.each do |iv, value|
+        @base.instance_variable_set("@#{iv}".to_sym, value)
+      end
+
+      result = @base.instance_variables_hash
+      assert_equal data.length, result.length
+
+      data.each do |iv, value|
+        assert_equal value, result[iv]
+      end
+    end
+
+    context "converting to JSON" do
+      should "convert instance variable hash to json" do
+        @json = mock("json")
+        @iv_hash = mock("iv_hash")
+        @iv_hash.expects(:to_json).once.returns(@json)
+        @base.expects(:instance_variables_hash).returns(@iv_hash)
+        assert_equal @json, @base.to_json
+      end
+
+      should "not include env in the JSON hash" do
+        @base.env = "FOO"
+        hash = @base.instance_variables_hash
+        assert !hash.has_key?(:env)
+      end
+    end
+  end
+
+  context "top config class" do
+    setup do
+      @configures_list = []
+      Vagrant::Config::Top.stubs(:configures_list).returns(@configures_list)
+    end
+
+    context "adding configure keys" do
+      setup do
+        @key = "top_config_foo"
+        @klass = mock("klass")
+      end
+
+      should "add key and klass to configures list" do
+        @configures_list.expects(:<<).with([@key, @klass])
+        Vagrant::Config::Top.configures(@key, @klass)
+      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(:env=).with(env)
+          klass.expects(:new).returns(instance)
+          @configures_list << [key, klass]
+        end
+
+        Vagrant::Config::Top.new(env)
+      end
+
+      should "allow reading via methods" do
+        key = "my_foo_bar_key"
+        klass = mock("klass")
+        instance = mock("instance")
+        instance.stubs(:env=)
+        klass.expects(:new).returns(instance)
+        Vagrant::Config::Top.configures(key, klass)
+
+        config = Vagrant::Config::Top.new
+        assert_equal instance, config.send(key)
+      end
+    end
+
+    context "loaded status" do
+      setup do
+        @top= Vagrant::Config::Top.new
+      end
+
+      should "not be loaded by default" do
+        assert !@top.loaded?
+      end
+
+      should "be loaded after calling loaded!" do
+        @top.loaded!
+        assert @top.loaded?
+      end
+    end
+
+    context "deep cloning" do
+      class DeepCloneConfig < Vagrant::Config::Base
+        attr_accessor :attribute
+      end
+
+      setup do
+        Vagrant::Config::Top.configures :deep, DeepCloneConfig
+        @top = Vagrant::Config::Top.new
+        @top.deep.attribute = [1,2,3]
+      end
+
+      should "deep clone the object" do
+        copy = @top.deep_clone
+        copy.deep.attribute << 4
+        assert_not_equal @top.deep.attribute, copy.deep.attribute
+        assert_equal 3, @top.deep.attribute.length
+        assert_equal 4, copy.deep.attribute.length
+      end
+    end
+  end
+
+  context "vagrant configuration" do
+    setup do
+      @config = Vagrant::Config::VagrantConfig.new
+    end
+
+    should "return nil if home is nil" do
+      File.expects(:expand_path).never
+      assert @config.home.nil?
+    end
+
+    should "expand the path if home is not nil" do
+      @config.home = "foo"
+      File.expects(:expand_path).with("foo").once.returns("result")
+      assert_equal "result", @config.home
+    end
+  end
+
+  context "VM configuration" do
+    setup do
+      @env = mock_environment
+      @config = @env.config.vm
+      @env.config.ssh.username = @username
+    end
+
+    context "defining VMs" do
+      should "store the proc by name but not run it" do
+        foo = mock("proc")
+        foo.expects(:call).never
+
+        proc = Proc.new { foo.call }
+        @config.define(:name, &proc)
+        assert @config.defined_vms[:name].proc_stack.include?(proc)
+      end
+
+      should "store the options" do
+        @config.define(:name, :set => true)
+        assert @config.defined_vms[:name].options[:set]
+      end
+
+      should "not have multi-VMs by default" do
+        assert !@config.has_multi_vms?
+      end
+
+      should "have multi-VMs once one is specified" do
+        @config.define(:foo) {}
+        assert @config.has_multi_vms?
+      end
+    end
+
+    context "customizing" do
+      should "include the stacked proc runner module" do
+        assert @config.class.included_modules.include?(Vagrant::Util::StackedProcRunner)
+      end
+
+      should "add the customize proc to the proc stack" do
+        proc = Proc.new {}
+        @config.customize(&proc)
+        assert_equal [proc], @config.proc_stack
+      end
+    end
+
+    context "uid/gid" do
+      should "return the shared folder UID if set" do
+        @config.shared_folder_uid = "foo"
+        assert_equal "foo", @config.shared_folder_uid
+      end
+
+      should "return the SSH username if UID not set" do
+        @config.shared_folder_uid = nil
+        assert_equal @username, @config.shared_folder_uid
+      end
+
+      should "return the shared folder GID if set" do
+        @config.shared_folder_gid = "foo"
+        assert_equal "foo", @config.shared_folder_gid
+      end
+
+      should "return the SSH username if GID not set" do
+        @config.shared_folder_gid = nil
+        assert_equal @username, @config.shared_folder_gid
+      end
+    end
+  end
+end

data/test/vagrant/downloaders/base_test.rb

@@ -0,0 +1,28 @@
+require "test_helper"
+
+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
+
+  context "base instance" do
+    setup do
+      @env = mock_environment
+      @base = Vagrant::Downloaders::Base.new(@env)
+    end
+
+    should "implement prepare which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:prepare)
+        @base.prepare("source")
+      end
+    end
+
+    should "implement download! which does nothing" do
+      assert_nothing_raised do
+        assert @base.respond_to?(:download!)
+        @base.download!("source", "destination")
+      end
+    end
+  end
+end

data/test/vagrant/downloaders/file_test.rb

@@ -0,0 +1,33 @@
+require "test_helper"
+
+class FileDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = mock_downloader(Vagrant::Downloaders::File)
+    @uri = "foo.box"
+  end
+
+  context "preparing" do
+    should "raise an exception if the file does not exist" do
+      File.expects(:file?).with(@uri).returns(false)
+      @downloader.prepare(@uri)
+      assert @downloader.env.error?
+      assert_equal :downloader_file_doesnt_exist, @downloader.env.error.first
+    end
+  end
+
+  context "downloading" do
+    should "cp the file" do
+      path = '/path'
+      @tempfile.expects(:path).returns(path)
+      FileUtils.expects(:cp).with(@uri, path)
+      @downloader.download!(@uri, @tempfile)
+    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')
+    end
+  end
+end

data/test/vagrant/downloaders/http_test.rb

@@ -0,0 +1,70 @@
+require "test_helper"
+
+class HttpDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = mock_downloader(Vagrant::Downloaders::HTTP)
+    @downloader.stubs(:report_progress)
+    @downloader.stubs(:complete_progress)
+    @uri = "http://google.com/"
+  end
+
+  context "downloading" do
+    setup do
+      @parsed_uri = URI.parse(@uri)
+      @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
+      Net::HTTP.stubs(:new).returns(@http)
+      @http.stubs(:start)
+    end
+
+    should "create a proper net/http object" do
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "enable SSL if scheme is https" do
+      @uri = "https://google.com/"
+      @http.expects(:use_ssl=).with(true).once
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "read the body of the response and place each segment into the file" do
+      h = mock("http")
+      response = mock("response")
+      response.stubs(:content_length)
+      segment = mock("segment")
+      segment.stubs(:length).returns(7)
+
+      @http.stubs(:start).yields(h)
+      h.expects(:request_get).with(@parsed_uri.request_uri).once.yields(response)
+      response.expects(:read_body).once.yields(segment)
+      @tempfile.expects(:write).with(segment).once
+
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "error environment if invalid URL given" do
+      Net::HTTP.expects(:new).raises(SocketError.new)
+      @downloader.download!(@uri, @tempfile)
+
+      assert @downloader.env.error?
+      assert_equal :box_download_http_socket_error, @downloader.env.error.first
+    end
+  end
+
+  context "matching the uri" do
+    should "use extract to verify that the string is in fact a uri" do
+      URI.expects(:extract).returns(['foo'])
+      assert Vagrant::Downloaders::HTTP.match?('foo')
+    end
+
+    should "return false if there are no extract results" do
+      URI.expects(:extract).returns([])
+      assert !Vagrant::Downloaders::HTTP.match?('foo')
+    end
+  end
+
+  context "reporting progress" do
+    # TODO: Testing for this, probably
+  end
+end