vagrant 0.4.2 → 0.5.0

data/test/vagrant/provisioners/base_test.rb

@@ -1,33 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', '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
-      @vm = mock("vm")
-      @base = Vagrant::Provisioners::Base.new(@vm)
-    end
-
-    should "set the environment" do
-      base = Vagrant::Provisioners::Base.new(@vm)
-      assert_equal @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

@@ -1,176 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class ChefServerProvisionerTest < Test::Unit::TestCase
-  setup do
-    @vm = mock_vm
-    @env = @vm.env
-    @action = Vagrant::Provisioners::ChefServer.new(@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)
-
-      assert_nothing_raised { @action.prepare }
-    end
-
-    should "raise 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)
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
-      }
-    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)
-      assert_nothing_raised { @action.prepare }
-    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)
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
-      }
-    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)
-
-      assert_nothing_raised { @action.prepare }
-    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)
-
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
-      }
-    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 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

@@ -1,183 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class ChefSoloProvisionerTest < Test::Unit::TestCase
-  setup do
-    @vm = mock_vm
-    @env = @vm.env
-    @action = Vagrant::Provisioners::ChefSolo.new(@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 "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.to_json, @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.to_json, @action.folders_path([0], @folder)
-    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 = mock("result")
-      @action.stubs(:host_cookbook_paths).returns([])
-      @action.expects(:folders_path).with(@action.host_cookbook_paths, "cookbooks").once.returns(result)
-      assert_equal result, @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 = mock("result")
-      @action.stubs(:host_role_paths).returns([])
-      @action.expects(:folders_path).with(@action.host_role_paths, "roles").once.returns(result)
-      assert_equal result, @action.roles_path
-    end
-  end
-
-  context "generating and uploading chef solo configuration file" do
-    setup do
-      @vm.ssh.stubs(:upload!)
-    end
-
-    should "call setup_config with proper variables" do
-      @action.expects(:setup_config).with("chef_solo_solo", "solo.rb", {
-        :provisioning_path => @env.config.chef.provisioning_path,
-        :cookbooks_path => @action.cookbooks_path,
-        :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 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

data/test/vagrant/provisioners/chef_test.rb

@@ -1,175 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
-
-class ChefProvisionerTest < Test::Unit::TestCase
-  setup do
-    @vm = mock_vm
-    @env = @vm.env
-    @action = Vagrant::Provisioners::Chef.new(@vm)
-  end
-
-  context "preparing" do
-    should "raise an ActionException" do
-      assert_raises(Vagrant::Actions::ActionException) {
-        @action.prepare
-      }
-    end
-  end
-
-  context "config" do
-    setup do
-      @config = Vagrant::Provisioners::Chef::ChefConfig.new
-      @config.run_list.clear
-    end
-
-    should "not include the 'json' key in the config dump" do
-      result = JSON.parse(@config.to_json)
-      assert !result.has_key?("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 "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(:exec!).with("which #{binary}", :error_key => :chef_not_detected, :error_data => { :binary => binary }).once
-      @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(:exec!).with("sudo mkdir -p #{@env.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
-      ssh.expects(:exec!).with("sudo chown #{@env.config.ssh.username} #{@env.config.chef.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(@env.config.chef.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 @env.config.chef.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
-      @env.config.chef.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(@env.config.chef.provisioning_path, "dna.json").once.returns("baz")
-      @vm.ssh.expects(:upload!).with("bar", "baz").once
-      @action.setup_json
-    end
-  end
-end