fixed-vagrant 0.7.4.dev

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -0,0 +1,219 @@
+require "test_helper"
+
+class ChefSoloProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Provisioners::ChefSolo
+
+    @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.cookbooks_path = "cookbooks"
+    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 cookbooks path is empty" do
+      @config.cookbooks_path = nil
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+  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")
+      @config.stubs(:cookbooks_path).returns("foo")
+      @action.expects(:host_folder_paths).with(@config.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")
+      @config.stubs(:roles_path).returns("foo")
+      @action.expects(:host_folder_paths).with(@config.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(@config.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
+      @config.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(@config.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(@config.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(@config.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(@config.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!)
+
+      @config.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 => @config.node_name,
+        :provisioning_path => @config.provisioning_path,
+        :cookbooks_path => @action.cookbooks_path,
+        :recipe_url => @config.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(:sudo!).with(["cd #{@config.provisioning_path}", "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(:sudo!).yields(nil, :exit_status, :foo)
+      @ssh.expects(:check_exit_status).with(:foo, anything).once
+      @action.run_chef_solo
+    end
+  end
+end

data/test/vagrant/provisioners/chef_test.rb

@@ -0,0 +1,179 @@
+require "test_helper"
+
+class ChefProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
+
+    @klass = Vagrant::Provisioners::Chef
+    @config = @klass::Config.new
+    @action = @klass.new(@action_env, @config)
+    @env = @action.env
+    @vm = @action.vm
+  end
+
+  context "preparing" do
+    should "error the environment" do
+      assert_raises(@klass::ChefError) {
+        @action.prepare
+      }
+    end
+  end
+
+  context "config" do
+    should "not include the 'json' key in the config dump" do
+      result = @config.to_json
+      assert result !~ /"json":/
+    end
+
+    should "provide accessors to the run list" do
+      @config.run_list << "foo"
+      assert !@config.run_list.empty?
+      assert_equal ["foo"], @config.run_list
+    end
+
+    should "provide a writer for the run list" do
+      data = mock("data")
+
+      assert_nothing_raised {
+        @config.run_list = data
+        assert_equal data, @config.run_list
+      }
+    end
+
+    should "have an empty run list to begin with" do
+      assert @config.run_list.empty?
+    end
+
+    should "add a recipe to the run list" do
+      @config.add_recipe("foo")
+      assert_equal "recipe[foo]", @config.run_list[0]
+    end
+
+    should "not wrap the recipe in 'recipe[]' if it was in the name" do
+      @config.add_recipe("recipe[foo]")
+      assert_equal "recipe[foo]", @config.run_list[0]
+    end
+
+    should "add a role to the run list" do
+      @config.add_role("user")
+      assert_equal "role[user]", @config.run_list[0]
+    end
+
+    should "not wrap the role in 'role[]' if it was in the name" do
+      @config.add_role("role[user]")
+      assert_equal "role[user]", @config.run_list[0]
+    end
+  end
+
+  context "verifying binary" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "verify binary exists" do
+      binary = "foo"
+      @ssh.expects(:sudo!).with("which #{binary}", anything)
+      @action.verify_binary(binary)
+    end
+  end
+
+  context "permissions on provisioning folder" do
+    should "create and chown the folder to the ssh user" do
+      ssh_seq = sequence("ssh_seq")
+      ssh = mock("ssh")
+      ssh.expects(:sudo!).with("mkdir -p #{@config.provisioning_path}").once.in_sequence(ssh_seq)
+      ssh.expects(:sudo!).with("chown #{@env.config.ssh.username} #{@config.provisioning_path}").once.in_sequence(ssh_seq)
+      @vm.ssh.expects(:execute).yields(ssh)
+      @action.chown_provisioning_folder
+    end
+  end
+
+  context "generating and uploading chef configuration file" do
+    setup do
+      @vm.ssh.stubs(:upload!)
+
+      @template = "template"
+      @filename = "foo.rb"
+
+      Vagrant::Util::TemplateRenderer.stubs(:render).returns("foo")
+    end
+
+    should "render and upload file" do
+      template_data = mock("data")
+      string_io = mock("string_io")
+      Vagrant::Util::TemplateRenderer.expects(:render).with(@template, anything).returns(template_data)
+      StringIO.expects(:new).with(template_data).returns(string_io)
+      File.expects(:join).with(@config.provisioning_path, @filename).once.returns("bar")
+      @vm.ssh.expects(:upload!).with(string_io, "bar")
+
+      @action.setup_config(@template, @filename, {})
+    end
+
+    should "provide log level by default" do
+      Vagrant::Util::TemplateRenderer.expects(:render).returns("foo").with() do |template, vars|
+        assert vars.has_key?(:log_level)
+        assert_equal @config.log_level.to_sym, vars[:log_level]
+        true
+      end
+
+      @action.setup_config(@template, @filename, {})
+    end
+
+    should "allow custom template variables" do
+      custom = {
+        :foo => "bar",
+        :int => 7
+      }
+
+      Vagrant::Util::TemplateRenderer.expects(:render).returns("foo").with() do |template, vars|
+        custom.each do |key, value|
+          assert vars.has_key?(key)
+          assert_equal value, vars[key]
+        end
+
+        true
+      end
+
+      @action.setup_config(@template, @filename, custom)
+    end
+  end
+
+  context "generating and uploading json" do
+    def assert_json
+      @vm.ssh.expects(:upload!).with do |json, path|
+        data = JSON.parse(json.read)
+        yield data
+        true
+      end
+
+      @action.setup_json
+    end
+
+    should "merge in the extra json specified in the config" do
+      @config.json = { :foo => "BAR" }
+      assert_json do |data|
+        assert_equal "BAR", data["foo"]
+      end
+    end
+
+    should "add the directory as a special case to the JSON" do
+      assert_json do |data|
+        assert_equal @env.config.vm.shared_folders["v-root"][:guestpath], data["vagrant"]["directory"]
+      end
+    end
+
+    should "add the config to the JSON" do
+      assert_json do |data|
+        assert_equal @env.config.ssh.username, data["vagrant"]["config"]["ssh"]["username"]
+      end
+    end
+
+    should "upload a StringIO to dna.json" do
+      StringIO.expects(:new).with(anything).returns("bar")
+      File.expects(:join).with(@config.provisioning_path, "dna.json").once.returns("baz")
+      @vm.ssh.expects(:upload!).with("bar", "baz").once
+      @action.setup_json
+    end
+  end
+end

data/test/vagrant/provisioners/puppet_server_test.rb

@@ -0,0 +1,68 @@
+require "test_helper"
+
+class PuppetServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @klass = Vagrant::Provisioners::PuppetServer
+
+    @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 "provisioning" do
+    should "run the proper sequence of methods in order" do
+      prov_seq = sequence("prov_seq")
+      @action.expects(:verify_binary).with("puppetd").once.in_sequence(prov_seq)
+      @action.expects(:run_puppetd_client).once.in_sequence(prov_seq)
+      @action.provision!
+    end
+  end
+
+  context "verifying binary" do
+    setup do
+      @ssh = mock("ssh")
+      @shell = mock("shell")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "verify binary exists" do
+      binary = "foo"
+      @ssh.expects(:sudo!).with("which #{binary}", anything)
+      @action.verify_binary(binary)
+    end
+  end
+
+  context "running puppetd client" do
+    setup do
+      @cn = "puppet_node"
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "run the puppetd client" do
+      @ssh.expects(:sudo!).with("puppetd  --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_client
+    end
+
+    should "run puppetd with given options when given as an array" do
+      @config.options = ["--modulepath", "modules", "--verbose"]
+      @ssh.expects(:sudo!).with("puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_client
+    end
+
+    should "run puppetd with the options when given as a string" do
+      @config.options = "--modulepath modules --verbose"
+      @ssh.expects(:sudo!).with("puppetd --modulepath modules --verbose --server #{@config.puppet_server} --certname #{@cn}").once
+      @action.run_puppetd_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_puppetd_client
+    end
+  end
+end