boxcar 0.10005.1

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

@@ -0,0 +1,115 @@
+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 "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 "creating expanded folder sets" do
+    should "expand VM folders properly" do
+      assert_equal [[:vm, nil, "/foo"]], @action.expanded_folders([:vm, "/foo"])
+    end
+
+    should "expand host folders properly" do
+      path = "foo"
+      local_path = File.expand_path(path, @env.root_path)
+      remote_path = "#{@action.config.provisioning_path}/chef-solo-1"
+      assert_equal [[:host, local_path, remote_path]], @action.expanded_folders([:host, path])
+    end
+
+    should "share roles and cookbooks in different folders" do
+      local_roles_path = File.expand_path('roles',@env.root_path)
+      local_cookbooks_path = File.expand_path('cookbooks',@env.root_path)
+      remote_roles_path = @action.expanded_folders([:host,local_roles_path])[0][2]
+      remote_cookbooks_path = @action.expanded_folders([:host,local_cookbooks_path])[0][2]
+      assert_not_equal remote_roles_path, remote_cookbooks_path
+    end
+  end
+
+  context "guest paths" do
+    should "extract the parts properly" do
+      structure = [[1,2,3],[1,2,3]]
+      assert_equal [3,3], @action.guest_paths(structure)
+    end
+  end
+
+  context "generating and uploading chef solo configuration file" do
+    setup do
+      @vm.ssh.stubs(:upload!)
+
+      @config.recipe_url = "foo/bar/baz"
+      @action.prepare
+    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.guest_paths(@action.cookbook_folders),
+        :recipe_url => @config.recipe_url,
+        :roles_path => @action.guest_paths(@action.role_folders).first,
+        :data_bags_path => @action.guest_paths(@action.data_bags_folders).first,
+        :encrypted_data_bag_secret => @config.encrypted_data_bag_secret
+      })
+
+      @action.setup_solo_config
+    end
+  end
+
+  context "running chef solo" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+    end
+
+    should "run chef solo" do
+      @ssh.expects(:sudo!).with("chef-solo -c #{@config.provisioning_path}/solo.rb -j #{@config.provisioning_path}/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/unit_legacy/vagrant/provisioners/chef_test.rb

@@ -0,0 +1,209 @@
+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 "not include the 'run_list' key in json if not accessed" do
+      result = @config.merged_json
+      assert !result.has_key?(:run_list)
+    end
+
+    should "include the 'run_list' key in json if it is set" do
+      @config.run_list << "foo"
+      result = @config.merged_json
+      assert result.has_key?(:run_list)
+    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 "chef binary path" do
+    should "return just the binary if no binary path is set" do
+      @config.binary_path = nil
+      assert_equal "foo", @action.chef_binary_path("foo")
+    end
+
+    should "return the joined binary path and binary if set" do
+      @config.binary_path = "/foo"
+      assert_equal File.join(@config.binary_path, "bar"), @action.chef_binary_path("bar")
+    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 "not add the directory if the 'v-root' shared folder doesn't exist" do
+      @env.config.vm.shared_folders.delete("v-root")
+      assert_json do |data|
+        assert !data["vagrant"].has_key?("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/unit_legacy/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

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

@@ -0,0 +1,182 @@
+require "test_helper"
+
+class PuppetProvisionerTest < Test::Unit::TestCase
+  setup do
+    clean_paths
+
+    @klass = Vagrant::Provisioners::Puppet
+
+    @action_env = Vagrant::Action::Environment.new(vagrant_env.vms[:default].env)
+
+    @config = @klass::Config.new
+    @config.top = Vagrant::Config::Top.new(@action_env.env)
+    @config.top.vm.box = "foo"
+    @action = @klass.new(@action_env, @config)
+    @env = @action.env
+    @vm = @action.vm
+  end
+
+  context "config" do
+    setup do
+      @errors = Vagrant::Config::ErrorRecorder.new
+
+      # Set a box
+      @config.top.vm.box = "foo"
+
+      # Start in a valid state (verified by the first test)
+      @config.expanded_manifests_path.mkdir
+      File.open(@config.expanded_manifests_path.join(@config.computed_manifest_file), "w") { |f| f.puts "HELLO" }
+    end
+
+    should "expand the manifest path relative to the root path" do
+      assert_equal File.expand_path(@config.manifests_path, @env.root_path), @config.expanded_manifests_path.to_s
+    end
+
+    should "default the manifest file to the box name" do
+      assert_equal "#{@config.top.vm.box}.pp", @config.computed_manifest_file
+    end
+
+    should "use the custom manifest file if set" do
+      @config.manifest_file = "woot.pp"
+      assert_equal "woot.pp", @config.computed_manifest_file
+    end
+
+    should "return an empty array if no module path is set" do
+      @config.module_path = nil
+      assert_equal [], @config.expanded_module_paths
+    end
+
+    should "return array of module paths expanded relative to root path" do
+      @config.module_path = "foo"
+
+      result = @config.expanded_module_paths
+      assert result.is_a?(Array)
+      assert_equal 1, result.length
+      assert_equal File.expand_path(@config.module_path, @env.root_path), result[0].to_s
+    end
+
+    should "be valid" do
+      @config.validate(@errors)
+      assert @errors.errors.empty?
+    end
+
+    should "be invalid if the manifests path doesn't exist" do
+      @config.expanded_manifests_path.rmtree
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if a custom manifests path doesn't exist" do
+      @config.manifests_path = "dont_exist"
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if the manifest file doesn't exist" do
+      @config.expanded_manifests_path.join(@config.computed_manifest_file).unlink
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be invalid if a specified module path doesn't exist" do
+      @config.module_path = "foo"
+      @config.validate(@errors)
+      assert !@errors.errors.empty?
+    end
+
+    should "be valid if all module paths exist" do
+      @config.module_path = "foo"
+      @config.expanded_module_paths.first.mkdir
+      @config.validate(@errors)
+      assert @errors.errors.empty?
+    end
+  end
+
+  context "preparing" do
+    should "share manifests" do
+      pre_seq = sequence("prepare")
+      @action.expects(:set_module_paths).once.in_sequence(pre_seq)
+      @action.expects(:share_manifests).once.in_sequence(pre_seq)
+      @action.expects(:share_module_paths).once.in_sequence(pre_seq)
+      @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("puppet").once.in_sequence(prov_seq)
+      @action.expects(:run_puppet_client).once.in_sequence(prov_seq)
+      @action.provision!
+    end
+  end
+
+  context "share manifests folder" do
+    should "share manifest folder" do
+      @env.config.vm.expects(:share_folder).with("manifests", @action.manifests_guest_path, @config.expanded_manifests_path)
+      @action.share_manifests
+    end
+  end
+
+  context "sharing module paths" do
+    should "share all the module paths" do
+      @config.module_path = ["foo", "bar"]
+      @config.expanded_module_paths.each_with_index do |path, i|
+        @env.config.vm.expects(:share_folder).with("v-pp-m#{i}", File.join(@config.pp_path, "modules-#{i}"), path)
+      end
+
+      @action.set_module_paths
+      @action.share_module_paths
+    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 "running puppet client" do
+    setup do
+      @ssh = mock("ssh")
+      @vm.ssh.stubs(:execute).yields(@ssh)
+      @action.set_module_paths
+    end
+
+    def expect_puppet_command(command)
+      @ssh.expects(:sudo!).with(["cd #{@action.manifests_guest_path}", command])
+    end
+
+    should "cd into the pp_path directory and run puppet" do
+      expect_puppet_command("puppet apply #{@config.computed_manifest_file}")
+      @action.run_puppet_client
+    end
+
+    should "cd into the pp_path directory and run puppet with given options when given as an array" do
+      @config.options = ["--modulepath", "modules", "--verbose"]
+      expect_puppet_command("puppet apply --modulepath modules --verbose #{@config.computed_manifest_file}")
+      @action.run_puppet_client
+    end
+
+    should "cd into the pp_path directory and run puppet with the options when given as a string" do
+      @config.options = "--modulepath modules --verbose"
+      expect_puppet_command("puppet apply --modulepath modules --verbose #{@config.computed_manifest_file}")
+      @action.run_puppet_client
+    end
+
+    should "cd into the pp_path and run puppet with module paths if set" do
+      @config.module_path = "foo"
+      expect_puppet_command("puppet apply --modulepath '#{File.join(@config.pp_path, 'modules-0')}' #{@config.computed_manifest_file}")
+
+      @action.set_module_paths
+      @action.run_puppet_client
+    end
+  end
+end