nixme-vagrant 0.7.2

data/test/vagrant/errors_test.rb

@@ -0,0 +1,42 @@
+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/vagrant/hosts/base_test.rb

@@ -0,0 +1,46 @@
+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/vagrant/hosts/bsd_test.rb

@@ -0,0 +1,53 @@
+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/vagrant/hosts/linux_test.rb

@@ -0,0 +1,54 @@
+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/vagrant/plugin_test.rb

@@ -0,0 +1,9 @@
+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/vagrant/provisioners/base_test.rb

@@ -0,0 +1,63 @@
+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/vagrant/provisioners/chef_server_test.rb

@@ -0,0 +1,186 @@
+require "test_helper"
+
+class ChefServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Provisioners::ChefServer
+
+    @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
+      })
+
+      @action.setup_server_config
+    end
+  end
+
+  context "running chef client" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "cd into the provisioning directory and run chef client" do
+      @ssh.expects(:sudo!).with(["cd #{@config.provisioning_path}", "chef-client -c client.rb -j 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