vagrant 0.8.10 → 0.9.0

data/test/unit_legacy/vagrant/box_collection_test.rb

@@ -0,0 +1,45 @@
+require "test_helper"
+
+class BoxCollectionTest < Test::Unit::TestCase
+  setup do
+    clean_paths
+
+    @klass = Vagrant::BoxCollection
+  end
+
+  should "load all the boxes from the box path" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    result = @klass.new(vagrant_env)
+    names = result.collect { |b| b.name }.sort
+    assert result.length >= 2
+    assert names.include?("foo")
+    assert names.include?("bar")
+  end
+
+  should "reload the box list" do
+    instance = @klass.new(vagrant_env)
+    amount = instance.length
+
+    vagrant_box("foo")
+
+    instance.reload!
+    assert_equal (amount + 1), instance.length
+  end
+
+  should "find a specific box" do
+    vagrant_box("foo")
+    vagrant_box("bar")
+
+    instance = @klass.new(vagrant_env)
+    result = instance.find("foo")
+    assert result
+    assert_equal "foo", result.name
+  end
+
+  should "return nil if it couldn't find a specific box" do
+    instance = @klass.new(vagrant_env)
+    assert_nil instance.find("thisshouldnotexist")
+  end
+end

data/test/unit_legacy/vagrant/box_test.rb

@@ -0,0 +1,74 @@
+require "test_helper"
+
+class BoxTest < Test::Unit::TestCase
+  context "class methods" do
+    setup do
+      @env = vagrant_env
+    end
+
+    context "adding" do
+      setup do
+        @name = "foo"
+        @uri = "bar"
+      end
+
+      should "create a new instance, set the variables, and add it" do
+        box = mock("box")
+        box.expects(:uri=).with(@uri)
+        box.expects(:add).once
+        Vagrant::Box.expects(:new).with(@env, @name).returns(box)
+        Vagrant::Box.add(@env, @name, @uri)
+      end
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @box = Vagrant::Box.new(vagrant_env, "foo")
+    end
+
+    should "raise an exception if a box exists with the name we're attempting to add" do
+      vagrant_box(@box.name)
+
+      assert_raises(Vagrant::Errors::BoxAlreadyExists) {
+        @box.add
+      }
+    end
+
+    should "execute the Add action when add is called" do
+      @box.env.actions.expects(:run).with(:box_add, { "box" => @box, "validate" => false })
+      @box.add
+    end
+
+    context "box directory" do
+      should "return the boxes_path joined with the name" do
+        assert_equal @box.env.boxes_path.join(@box.name), @box.directory
+      end
+    end
+
+    context "destroying" do
+      should "execute the destroy action" do
+        @box.env.actions.expects(:run).with(:box_remove, { "box" => @box, "validate" => false })
+        @box.destroy
+      end
+    end
+
+    context "repackaging" do
+      should "execute the repackage action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "validate" => false })
+        @box.repackage
+      end
+
+      should "forward given options into the action" do
+        @box.env.actions.expects(:run).with(:box_repackage, { "box" => @box, "foo" => "bar", "validate" => false })
+        @box.repackage("foo" => "bar")
+      end
+    end
+
+    context "ovf file" do
+      should "be the directory joined with the config ovf file" do
+        assert_equal @box.directory.join(@box.env.config.vm.box_ovf), @box.ovf_file
+      end
+    end
+  end
+end

data/test/unit_legacy/vagrant/command/base_test.rb

@@ -0,0 +1,23 @@
+require "test_helper"
+
+class CommandBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Command::Base
+    @env = vagrant_env
+  end
+
+  context "initialization" do
+    should "require an environment" do
+      assert_raises(Vagrant::Errors::CLIMissingEnvironment) { @klass.new([], {}, {}) }
+      assert_nothing_raised { @klass.new([], {}, { :env => @env }) }
+    end
+  end
+
+  context "extracting a name from a usage string" do
+    should "extract properly" do
+      assert_equal "init", @klass.extract_name_from_usage("init")
+      assert_equal "init", @klass.extract_name_from_usage("init [foo] [bar]")
+      assert_equal "ssh-config", @klass.extract_name_from_usage("ssh-config")
+    end
+  end
+end

data/test/unit_legacy/vagrant/config/base_test.rb

@@ -0,0 +1,52 @@
+require "test_helper"
+
+class ConfigBaseTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config::Base
+  end
+
+  context "class methods" do
+    should "enable configuration with proper accessor" do
+      klass = Class.new(@klass)
+      acc = :foo
+      Vagrant::Config::Top.expects(:configures).with(acc, klass)
+      klass.configures(acc)
+    end
+  end
+
+  context "instance methods" do
+    setup do
+      @base = @klass.new
+    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 "include magic `json_class`" do
+        @iv_hash = { "foo" => "bar" }
+        @base.expects(:instance_variables_hash).returns(@iv_hash)
+        @json = { 'json_class' => @base.class.name }.merge(@iv_hash).to_json
+        assert_equal @json, @base.to_json
+      end
+
+      should "not include top in the JSON hash" do
+        @base.top = "FOO"
+        hash = @base.instance_variables_hash
+        assert !hash.has_key?(:top)
+      end
+    end
+  end
+end

data/test/unit_legacy/vagrant/config/vm_test.rb

@@ -0,0 +1,47 @@
+require "test_helper"
+
+class ConfigVMTest < Test::Unit::TestCase
+  setup do
+    @username = "mitchellh"
+
+    @env = vagrant_env
+    @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 "retain vm definition order" do
+      @config.define(:a) {}
+      @config.define(:b) {}
+      @config.define(:c) {}
+
+      assert_equal [:a, :b, :c], @config.defined_vm_keys
+    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 @config.proc_stack.include?(proc)
+    end
+  end
+end

data/test/unit_legacy/vagrant/config_test.rb

@@ -0,0 +1,148 @@
+require "test_helper"
+
+class ConfigTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Config
+  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"))
+      }
+    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
+
+      should "add key and klass to configures list" do
+        @klass::Top.configures(@key, @config_klass)
+        assert_equal @config_klass, @configures_list[@key]
+      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
+
+        @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
+  end
+end

data/test/unit_legacy/vagrant/downloaders/http_test.rb

@@ -0,0 +1,93 @@
+require "test_helper"
+
+class HttpDownloaderTest < Test::Unit::TestCase
+  setup do
+    @downloader, @tempfile = vagrant_mock_downloader(Vagrant::Downloaders::HTTP)
+    @downloader.stubs(:report_progress)
+    @downloader.stubs(:complete_progress)
+    @uri = "http://google.com/"
+    @headers = nil
+  end
+
+  context "downloading" do
+    setup do
+      ENV["http_proxy"] = nil
+
+      @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, nil, nil, nil, nil).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "create a proper net/http object with a proxy" do
+      ENV["http_proxy"] = "http://user:foo@google.com"
+      @proxy = URI.parse(ENV["http_proxy"])
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port, @proxy.host, @proxy.port, @proxy.user, @proxy.password).once.returns(@http)
+      @http.expects(:start)
+      @downloader.download!(@uri, @tempfile)
+    end
+
+    should "create a proper net/http object without a proxy if no_proxy defined" do
+      @uri = "http://somewhere.direct.com/some_file"
+      @parsed_uri = URI.parse(@uri)
+      ENV["http_proxy"] = "http://user:foo@google.com"
+      ENV["no_proxy"] = "direct.com"
+      Net::HTTP.expects(:new).with(@parsed_uri.host, @parsed_uri.port, nil, nil, nil, nil).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)
+      response.stubs(:is_a?).with(anything).returns(false)
+      response.stubs(:is_a?).with(Net::HTTPOK).returns(true)
+      segment = mock("segment")
+      segment.stubs(:length).returns(7)
+
+      @http.stubs(:start).yields(h)
+      h.expects(:request_get).with(@parsed_uri.request_uri, @headers).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)
+
+      assert_raises(Vagrant::Errors::DownloaderHTTPSocketError) {
+        @downloader.download!(@uri, @tempfile)
+      }
+    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