vagrantup 1.0.7 → 1.1.0

data/test/unit_legacy/vagrant/errors_test.rb

@@ -1,42 +0,0 @@
-require "test_helper"
-
-class ErrorsTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Errors::VagrantError
-    @super = Class.new(@klass) { error_namespace("vagrant.test.errors") }
-  end
-
-  should "set the given status code" do
-    klass = Class.new(@super) { status_code(4444) }
-    assert_equal 4444, klass.new.status_code
-  end
-
-  should "raise an error if attempting to set the same status code twice" do
-    klass = Class.new(@super) { status_code(4445) }
-
-    assert_raises(RuntimeError) {
-      Class.new(@super) { status_code(4445) }
-    }
-  end
-
-  should "translate the given message if non-hash is given" do
-    klass = Class.new(@super)
-    assert_equal I18n.t("vagrant.test.errors.test_key"), klass.new("test_key").message
-  end
-
-  should "use the alternate namespace if given" do
-    klass = Class.new(@super)
-    instance = klass.new(:_key => :test_key, :_namespace => "vagrant.test.alternate")
-    assert_equal I18n.t("vagrant.test.alternate.test_key"), instance.message
-  end
-
-  should "use the translation from I18n if specified" do
-    klass = Class.new(@super) { error_key(:test_key) }
-    assert_equal I18n.t("vagrant.test.errors.test_key"), klass.new.message
-  end
-
-  should "use the translation with the options specified if key given" do
-    klass = Class.new(@super) { error_key(:test_key_with_interpolation) }
-    assert_equal I18n.t("vagrant.test.errors.test_key_with_interpolation", :key => "yo"), klass.new(:key => "yo").message
-  end
-end

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

@@ -1,46 +0,0 @@
-require "test_helper"
-
-class BaseHostTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Hosts::Base
-  end
-
-  context "class methods" do
-    context "loading" do
-      setup do
-        @env = vagrant_env
-      end
-
-      should "return detected class if klass is nil" do
-        Vagrant::Util::Platform.stubs(:platform).returns("darwin")
-        result = @klass.load(@env, nil)
-        assert result.is_a?(Vagrant::Hosts::BSD)
-      end
-
-      should "instantiate the given class" do
-        result = @klass.load(@env, Vagrant::Hosts::BSD)
-        assert result.is_a?(Vagrant::Hosts::BSD)
-        assert_equal @env, result.env
-      end
-    end
-
-    context "detecting class" do
-      should "return the proper class" do
-        Vagrant::Util::Platform.stubs(:platform).returns("darwin10")
-        assert_equal Vagrant::Hosts::BSD, @klass.detect
-      end
-
-      should "return nil if no class is detected" do
-        Vagrant::Util::Platform.stubs(:platform).returns("boo")
-        assert_nil @klass.detect
-      end
-
-      should "return nil if an exception is raised" do
-        Vagrant::Util::Platform.stubs(:platform).returns("boo")
-        assert_nothing_raised {
-          assert_nil @klass.detect
-        }
-      end
-    end
-  end
-end

data/test/unit_legacy/vagrant/hosts/bsd_test.rb

@@ -1,53 +0,0 @@
-require "test_helper"
-
-class BSDHostTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Hosts::BSD
-    @env = vagrant_env
-    @instance = @klass.new(@env.vms.values.first.env)
-  end
-
-  context "supporting nfs check" do
-    should "support NFS" do
-      @instance.expects(:system).returns(true)
-      assert @instance.nfs?
-    end
-
-    should "not support NFS if nfsd is not found" do
-      @instance.expects(:system).returns(false)
-      assert !@instance.nfs?
-    end
-
-    should "retry until a boolean is returned" do
-      seq = sequence("seq")
-      @instance.expects(:system).in_sequence(seq).raises(TypeError.new("foo"))
-      @instance.expects(:system).in_sequence(seq).returns(true)
-      assert @instance.nfs?
-    end
-  end
-
-  context "nfs export" do
-    setup do
-      @instance.stubs(:system)
-
-      @ip = "foo"
-      @folders = "bar"
-    end
-
-    should "output the lines of the rendered template" do
-      output = %W[foo bar baz].join("\n")
-      Vagrant::Util::TemplateRenderer.expects(:render).with("nfs/exports",
-                                                            :uuid => @instance.env.vm.uuid,
-                                                            :ip => @ip,
-                                                            :folders => @folders).returns(output)
-
-      @instance.expects(:system).times(output.split("\n").length)
-      @instance.expects(:system).with("sudo nfsd restart")
-      @instance.nfs_export(@ip, @folders)
-    end
-  end
-
-  context "nfs cleanup" do
-    # TODO: How to test all the system calls?
-  end
-end

data/test/unit_legacy/vagrant/hosts/linux_test.rb

@@ -1,54 +0,0 @@
-require "test_helper"
-
-class LinuxHostTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Hosts::Linux
-    @env = vagrant_env
-
-    @instance = @klass.new(@env.vms.values.first.env)
-  end
-
-  context "supporting nfs check" do
-    should "support NFS" do
-      @instance.expects(:system).returns(true)
-      assert @instance.nfs?
-    end
-
-    should "not support NFS if nfsd is not found" do
-      @instance.expects(:system).returns(false)
-      assert !@instance.nfs?
-    end
-
-    should "retry until a boolean is returned" do
-      seq = sequence("seq")
-      @instance.expects(:system).in_sequence(seq).raises(TypeError.new("foo"))
-      @instance.expects(:system).in_sequence(seq).returns(true)
-      assert @instance.nfs?
-    end
-  end
-
-  context "nfs export" do
-    setup do
-      @instance.stubs(:system)
-
-      @ip = "foo"
-      @folders = "bar"
-    end
-
-    should "output the lines of the rendered template" do
-      output = %W[foo bar baz].join("\n")
-      Vagrant::Util::TemplateRenderer.expects(:render).with("nfs/exports_linux",
-                                                            :uuid => @instance.env.vm.uuid,
-                                                            :ip => @ip,
-                                                            :folders => @folders).returns(output)
-
-      @instance.expects(:system).times(output.split("\n").length)
-      @instance.expects(:system).with("sudo /etc/init.d/nfs-kernel-server restart")
-      @instance.nfs_export(@ip, @folders)
-    end
-  end
-
-  context "nfs cleanup" do
-    # TODO: How to test all the system calls?
-  end
-end

data/test/unit_legacy/vagrant/plugin_test.rb

@@ -1,9 +0,0 @@
-require "test_helper"
-
-class PluginTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Plugin
-  end
-
-  # This is a pretty tough class to test. TODO.
-end

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

@@ -1,63 +0,0 @@
-require "test_helper"
-
-class BaseProvisionerTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Provisioners::Base
-  end
-
-  should "include the util class so subclasses have access to it" do
-    assert Vagrant::Provisioners::Base.include?(Vagrant::Util)
-  end
-
-  context "registering provisioners" do
-    teardown do
-      @klass.registered.delete(:zomg)
-    end
-
-    should "not have unregistered provisioners" do
-      assert_nil @klass.registered[:foo]
-    end
-
-    should "be able to register a provisioner" do
-      foo = Class.new(@klass) do
-        register :zomg
-      end
-
-      assert_equal foo, @klass.registered[:zomg]
-    end
-  end
-
-  context "base instance" do
-    setup do
-      @env = Vagrant::Action::Environment.new(vagrant_env)
-      @config = mock("config")
-      @base = Vagrant::Provisioners::Base.new(@env, @config)
-    end
-
-    should "set the environment" do
-      assert_equal @env.env, @base.env
-    end
-
-    should "return the VM which the provisioner is acting on" do
-      assert_equal @env.env.vm, @base.vm
-    end
-
-    should "provide access to the config" do
-      assert_equal @config, @base.config
-    end
-
-    should "implement provision! which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:provision!)
-        @base.provision!
-      end
-    end
-
-    should "implement prepare which does nothing" do
-      assert_nothing_raised do
-        assert @base.respond_to?(:prepare)
-        @base.prepare
-      end
-    end
-  end
-end

data/test/unit_legacy/vagrant/provisioners/chef_client_test.rb

@@ -1,190 +0,0 @@
-require "test_helper"
-
-class ChefClientProvisionerTest < Test::Unit::TestCase
-  setup do
-    @klass = Vagrant::Provisioners::ChefClient
-
-    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
-
-    @config = @klass::Config.new
-    @action = @klass.new(@action_env, @config)
-    @env = @action.env
-    @vm = @action.vm
-  end
-
-  context "config validation" do
-    setup do
-      @errors = Vagrant::Config::ErrorRecorder.new
-
-      @config.run_list = ["foo"]
-      @config.chef_server_url = "foo"
-      @config.validation_key_path = "foo"
-    end
-
-    should "be invalid if run list is empty" do
-      @config.run_list = []
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if run list is empty" do
-      @config.chef_server_url = nil
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-
-    should "be invalid if run list is empty" do
-      @config.validation_key_path = nil
-      @config.validate(@errors)
-      assert !@errors.errors.empty?
-    end
-  end
-
-  context "provisioning" do
-    should "run the proper sequence of methods in order" do
-      prov_seq = sequence("prov_seq")
-      @action.expects(:verify_binary).with("chef-client").once.in_sequence(prov_seq)
-      @action.expects(:chown_provisioning_folder).once.in_sequence(prov_seq)
-      @action.expects(:create_client_key_folder).once.in_sequence(prov_seq)
-      @action.expects(:upload_validation_key).once.in_sequence(prov_seq)
-      @action.expects(:setup_json).once.in_sequence(prov_seq)
-      @action.expects(:setup_server_config).once.in_sequence(prov_seq)
-      @action.expects(:run_chef_client).once.in_sequence(prov_seq)
-      @action.provision!
-    end
-  end
-
-  context "preparing" do
-    setup do
-      File.stubs(:file?).returns(true)
-    end
-
-    should "not raise an exception if validation_key_path is set" do
-      @config.validation_key_path = "7"
-      @config.chef_server_url = "7"
-
-      assert_nothing_raised { @action.prepare }
-    end
-
-    should "raise an exception if validation_key_path is nil" do
-      @config.validation_key_path = nil
-
-      assert_raises(Vagrant::Provisioners::Chef::ChefError) {
-        @action.prepare
-      }
-    end
-
-    should "not raise an exception if validation_key_path does exist" do
-      @config.validation_key_path = vagrantfile(tmp_path)
-      @config.chef_server_url = "7"
-
-      assert_nothing_raised { @action.prepare }
-    end
-
-    should "raise an exception if validation_key_path doesn't exist" do
-      @config.validation_key_path = "7"
-      @config.chef_server_url = "7"
-
-      File.expects(:file?).with(@action.validation_key_path).returns(false)
-      assert_raises(Vagrant::Provisioners::Chef::ChefError) {
-        @action.prepare
-      }
-    end
-
-    should "not raise an exception if chef_server_url is set" do
-      @config.validation_key_path = vagrantfile(tmp_path)
-      @config.chef_server_url = "7"
-
-      assert_nothing_raised { @action.prepare }
-    end
-
-    should "raise an exception if chef_server_url is nil" do
-      @config.chef_server_url = nil
-
-      assert_raises(Vagrant::Provisioners::Chef::ChefError) {
-        @action.prepare
-      }
-    end
-  end
-
-  context "creating the client key folder" do
-    setup do
-      @raw_path = "/foo/bar/baz.pem"
-      @config.client_key_path = @raw_path
-
-      @path = Pathname.new(@raw_path)
-    end
-
-    should "create the folder using the dirname of the path" do
-      ssh = mock("ssh")
-      ssh.expects(:sudo!).with("mkdir -p #{@path.dirname}").once
-      @vm.ssh.expects(:execute).yields(ssh)
-      @action.create_client_key_folder
-    end
-  end
-
-  context "uploading the validation key" do
-    should "upload the validation key to the provisioning path" do
-      @action.expects(:validation_key_path).once.returns("foo")
-      @action.expects(:guest_validation_key_path).once.returns("bar")
-      @vm.ssh.expects(:upload!).with("foo", "bar").once
-      @action.upload_validation_key
-    end
-  end
-
-  context "the validation key path" do
-    should "expand the configured key path" do
-      result = mock("result")
-      File.expects(:expand_path).with(@config.validation_key_path, @env.root_path).once.returns(result)
-      assert_equal result, @action.validation_key_path
-    end
-  end
-
-  context "the guest validation key path" do
-    should "be the provisioning path joined with validation.pem" do
-      result = mock("result")
-      File.expects(:join).with(@config.provisioning_path, "validation.pem").once.returns(result)
-      assert_equal result, @action.guest_validation_key_path
-    end
-  end
-
-  context "generating and uploading chef client configuration file" do
-    setup do
-      @action.stubs(:guest_validation_key_path).returns("foo")
-    end
-
-    should "call setup_config with proper variables" do
-      @action.expects(:setup_config).with("chef_server_client", "client.rb", {
-        :node_name => @config.node_name,
-        :chef_server_url => @config.chef_server_url,
-        :validation_client_name => @config.validation_client_name,
-        :validation_key => @action.guest_validation_key_path,
-        :client_key => @config.client_key_path,
-        :file_cache_path => @config.file_cache_path,
-        :file_backup_path => @config.file_backup_path,
-        :environment => @config.environment,
-        :encrypted_data_bag_secret => @config.encrypted_data_bag_secret
-      })
-
-      @action.setup_server_config
-    end
-  end
-
-  context "running chef client" do
-    setup do
-      @ssh = mock("ssh")
-      @vm.ssh.stubs(:execute).yields(@ssh)
-    end
-
-    should "run chef client" do
-      @ssh.expects(:sudo!).with("chef-client -c #{@config.provisioning_path}/client.rb -j #{@config.provisioning_path}/dna.json").once
-      @action.run_chef_client
-    end
-
-    should "check the exit status if that is given" do
-      @ssh.stubs(:sudo!).yields(nil, :exit_status, :foo)
-      @ssh.expects(:check_exit_status).with(:foo, anything).once
-      @action.run_chef_client
-    end
-  end
-end