vagrantup 0.5.2 → 0.5.3

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 = mock_environment
+      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,56 @@
+require "test_helper"
+
+class BSDHostTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Hosts::BSD
+    @env = mock_environment
+    @env.stubs(:vm).returns(Vagrant::VM.new(:env => @env))
+    @env.logger.stubs(:info)
+
+    @instance = @klass.new(@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 => @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,56 @@
+require "test_helper"
+
+class LinuxHostTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Hosts::Linux
+    @env = mock_environment
+    @env.stubs(:vm).returns(Vagrant::VM.new(:env => @env))
+    @env.logger.stubs(:info)
+
+    @instance = @klass.new(@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 => @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/provisioners/base_test.rb

@@ -0,0 +1,36 @@
+require "test_helper"
+
+class BaseProvisionerTest < Test::Unit::TestCase
+  should "include the util class so subclasses have access to it" do
+    assert Vagrant::Provisioners::Base.include?(Vagrant::Util)
+  end
+
+  context "base instance" do
+    setup do
+      @env = Vagrant::Action::Environment.new(mock_environment)
+      @base = Vagrant::Provisioners::Base.new(@env)
+    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 "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,182 @@
+require "test_helper"
+
+class ChefServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action_env = Vagrant::Action::Environment.new(mock_environment)
+    @action_env.env.vm = mock_vm
+
+    @action = Vagrant::Provisioners::ChefServer.new(@action_env)
+    @env = @action.env
+    @vm = @action.vm
+  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
+      @env = mock_environment do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      @action.stubs(:env).returns(@env)
+
+      @action.prepare
+      assert !@action_env.error?
+    end
+
+    should "eraise an exception if validation_key_path is nil" do
+      @env = mock_environment do |config|
+        config.chef.validation_key_path = nil
+      end
+
+      @action.stubs(:env).returns(@env)
+
+      @action.prepare
+      assert @action_env.error?
+      assert_equal :chef_server_validation_key_required, @action_env.error.first
+    end
+
+    should "not raise an exception if validation_key_path does exist" do
+      @env = mock_environment do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      @action.stubs(:env).returns(@env)
+      @action.stubs(:validation_key_path).returns("9")
+
+      File.expects(:file?).with(@action.validation_key_path).returns(true)
+      @action.prepare
+      assert !@action_env.error?
+    end
+
+    should "raise an exception if validation_key_path doesn't exist" do
+      @env = mock_environment do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      @action.stubs(:env).returns(@env)
+      @action.stubs(:validation_key_path).returns("9")
+
+      File.expects(:file?).with(@action.validation_key_path).returns(false)
+      @action.prepare
+      assert @action_env.error?
+      assert_equal :chef_server_validation_key_doesnt_exist, @action_env.error.first
+    end
+
+    should "not raise an exception if chef_server_url is set" do
+      @env = mock_environment do |config|
+        config.chef.chef_server_url = "7"
+      end
+
+      @action.stubs(:env).returns(@env)
+
+      @action.prepare
+      assert !@action_env.error?
+    end
+
+    should "raise an exception if chef_server_url is nil" do
+      @env = mock_environment do |config|
+        config.chef.chef_server_url = nil
+      end
+
+      @action.stubs(:env).returns(@env)
+
+      @action.prepare
+      assert @action_env.error?
+      assert_equal :chef_server_url_required, @action_env.error.first
+    end
+  end
+
+  context "creating the client key folder" do
+    setup do
+      @raw_path = "/foo/bar/baz.pem"
+      @env.config.chef.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(:exec!).with("sudo 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(@env.config.chef.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(@env.config.chef.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 => @env.config.chef.node_name,
+        :chef_server_url => @env.config.chef.chef_server_url,
+        :validation_client_name => @env.config.chef.validation_client_name,
+        :validation_key => @action.guest_validation_key_path,
+        :client_key => @env.config.chef.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(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo -E 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(:exec!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
+      @action.run_chef_client
+    end
+  end
+end

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -0,0 +1,197 @@
+require "test_helper"
+
+class ChefSoloProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action_env = Vagrant::Action::Environment.new(mock_environment)
+    @action_env.env.vm = mock_vm
+
+    @action = Vagrant::Provisioners::ChefSolo.new(@action_env)
+    @env = @action.env
+    @vm = @action.vm
+  end
+
+  context "preparing" do
+    should "share cookbook folders" do
+      @action.expects(:share_cookbook_folders).once
+      @action.prepare
+    end
+
+    should "share role folders" do
+      @action.expects(:share_role_folders).once
+      @action.prepare
+    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-solo").once.in_sequence(prov_seq)
+      @action.expects(:chown_provisioning_folder).once.in_sequence(prov_seq)
+      @action.expects(:setup_json).once.in_sequence(prov_seq)
+      @action.expects(:setup_solo_config).once.in_sequence(prov_seq)
+      @action.expects(:run_chef_solo).once.in_sequence(prov_seq)
+      @action.provision!
+    end
+  end
+  context "sharing cookbook folders" do
+    setup do
+      @host_cookbook_paths = ["foo", "bar"]
+      @action.stubs(:host_cookbook_paths).returns(@host_cookbook_paths)
+    end
+
+    should "share each cookbook folder" do
+      share_seq = sequence("share_seq")
+      @host_cookbook_paths.each_with_index do |cookbook, i|
+        @env.config.vm.expects(:share_folder).with("v-csc-#{i}", @action.cookbook_path(i), cookbook).in_sequence(share_seq)
+      end
+
+      @action.share_cookbook_folders
+    end
+  end
+
+  context "sharing role folders" do
+    setup do
+      @host_role_paths = ["foo", "bar"]
+      @action.stubs(:host_role_paths).returns(@host_role_paths)
+    end
+
+    should "share each role folder" do
+      share_seq = sequence("share_seq")
+      @host_role_paths.each_with_index do |role, i|
+        @env.config.vm.expects(:share_folder).with("v-csr-#{i}", @action.role_path(i), role).in_sequence(share_seq)
+      end
+
+      @action.share_role_folders
+    end
+  end
+
+  context "host folder paths" do
+    should "ignore VM paths" do
+      assert @action.host_folder_paths([:vm, "foo"]).empty?
+    end
+
+    should "return as an array if was originally a string" do
+      folder = "foo"
+      File.stubs(:expand_path).returns("bar")
+      assert_equal ["bar"], @action.host_folder_paths(folder)
+    end
+
+    should "return the array of folders if its an array" do
+      folders = ["foo", "bar"]
+      expand_seq = sequence('expand_seq')
+      folders.collect! { |folder| File.expand_path(folder, @env.root_path) }
+
+      assert_equal folders, @action.host_folder_paths(folders)
+    end
+  end
+
+  context "host cookbooks paths" do
+    should "get folders path for configured cookbooks path" do
+      result = mock("result")
+      @env.config.chef.stubs(:cookbooks_path).returns("foo")
+      @action.expects(:host_folder_paths).with(@env.config.chef.cookbooks_path).returns(result)
+      assert_equal result, @action.host_cookbook_paths
+    end
+  end
+
+  context "host roles paths" do
+    should "get folders path for configured roles path" do
+      result = mock("result")
+      @env.config.chef.stubs(:roles_path).returns("foo")
+      @action.expects(:host_folder_paths).with(@env.config.chef.roles_path).returns(result)
+      assert_equal result, @action.host_role_paths
+    end
+  end
+
+  context "folder path" do
+    should "return a proper path to a single folder" do
+      expected = File.join(@env.config.chef.provisioning_path, "cookbooks-5")
+      assert_equal expected, @action.folder_path("cookbooks", 5)
+    end
+
+    should "return array-representation of folder paths if multiple" do
+      @folders = (0..5).to_a
+      @cookbooks = @folders.inject([]) do |acc, i|
+        acc << @action.cookbook_path(i)
+      end
+
+      assert_equal @cookbooks, @action.folders_path(@folders, "cookbooks")
+    end
+
+    should "return a single string representation if folder paths is single" do
+      @folder = "cookbooks"
+      @cookbooks = @action.folder_path(@folder, 0)
+
+      assert_equal @cookbooks, @action.folders_path([0], @folder)
+    end
+
+    should "properly format VM folder paths" do
+      @env.config.chef.provisioning_path = "/foo"
+      assert_equal "/foo/bar", @action.folders_path([:vm, "bar"], nil)
+    end
+  end
+
+  context "cookbooks path" do
+    should "return a proper path to a single cookbook" do
+      expected = File.join(@env.config.chef.provisioning_path, "cookbooks-5")
+      assert_equal expected, @action.cookbook_path(5)
+    end
+
+    should "properly call folders path and return result" do
+      result = [:a, :b, :c]
+      @action.expects(:folders_path).with(@env.config.chef.cookbooks_path, "cookbooks").once.returns(result)
+      assert_equal result.to_json, @action.cookbooks_path
+    end
+  end
+
+  context "roles path" do
+    should "return a proper path to a single role" do
+      expected = File.join(@env.config.chef.provisioning_path, "roles-5")
+      assert_equal expected, @action.role_path(5)
+    end
+
+    should "properly call folders path and return result" do
+      result = [:a, :b, :c]
+      @action.expects(:folders_path).with(@env.config.chef.roles_path, "roles").once.returns(result)
+      assert_equal result.to_json, @action.roles_path
+    end
+  end
+
+  context "generating and uploading chef solo configuration file" do
+    setup do
+      @vm.ssh.stubs(:upload!)
+
+      @env.config.chef.recipe_url = "foo/bar/baz"
+    end
+
+    should "call setup_config with proper variables" do
+      @action.expects(:setup_config).with("chef_solo_solo", "solo.rb", {
+        :node_name => @env.config.chef.node_name,
+        :provisioning_path => @env.config.chef.provisioning_path,
+        :cookbooks_path => @action.cookbooks_path,
+        :recipe_url => @env.config.chef.recipe_url,
+        :roles_path => @action.roles_path
+      })
+
+      @action.setup_solo_config
+    end
+  end
+
+  context "running chef solo" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "cd into the provisioning directory and run chef solo" do
+      @ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo -E chef-solo -c solo.rb -j dna.json").once
+      @action.run_chef_solo
+    end
+
+    should "check the exit status if that is given" do
+      @ssh.stubs(:exec!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
+      @action.run_chef_solo
+    end
+  end
+end