vagrantup 0.1.4 → 0.2.0

data/test/vagrant/provisioners/chef_server_test.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ChefServerProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action = Vagrant::Provisioners::ChefServer.new
+
+    Vagrant::SSH.stubs(:execute)
+    Vagrant::SSH.stubs(:upload!)
+
+    mock_config
+  end
+
+  context "provisioning" do
+    should "run the proper sequence of methods in order" do
+      prov_seq = 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_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
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if validation_key_path is nil" do
+      mock_config do |config|
+        config.chef.validation_key_path = nil
+      end
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+
+    should "not raise an exception if validation_key_path does exist" do
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      File.expects(:file?).with(Vagrant.config.chef.validation_key_path).returns(true)
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if validation_key_path doesn't exist" do
+      mock_config do |config|
+        config.chef.validation_key_path = "7"
+      end
+
+      File.expects(:file?).with(Vagrant.config.chef.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
+      mock_config do |config|
+        config.chef.chef_server_url = "7"
+      end
+
+      assert_nothing_raised { @action.prepare }
+    end
+
+    should "raise an exception if chef_server_url is nil" do
+      mock_config do |config|
+        config.chef.chef_server_url = nil
+      end
+
+      assert_raises(Vagrant::Actions::ActionException) {
+        @action.prepare
+      }
+    end
+  end
+
+  context "creating the client key folder" do
+    setup do
+      @raw_path = "/foo/bar/baz.pem"
+      mock_config do |config|
+        config.chef.client_key_path = @raw_path
+      end
+
+      @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
+      Vagrant::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")
+      Vagrant::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(Vagrant.config.chef.validation_key_path, Vagrant::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(Vagrant.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 "upload properly generate the configuration file using configuration data" do
+      expected_config = <<-config
+log_level          :info
+log_location       STDOUT
+ssl_verify_mode    :verify_none
+chef_server_url    "#{Vagrant.config.chef.chef_server_url}"
+
+validation_client_name "#{Vagrant.config.chef.validation_client_name}"
+validation_key         "#{@action.guest_validation_key_path}"
+client_key             "#{Vagrant.config.chef.client_key_path}"
+
+file_store_path    "/srv/chef/file_store"
+file_cache_path    "/srv/chef/cache"
+
+pid_file           "/var/run/chef/chef-client.pid"
+
+Mixlib::Log::Formatter.show_time = true
+config
+
+      StringIO.expects(:new).with(expected_config).once
+      @action.setup_config
+    end
+
+    should "upload this file as client.rb to the provisioning folder" do
+      StringIO.expects(:new).returns("foo")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "client.rb").once.returns("bar")
+      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
+      @action.setup_config
+    end
+  end
+
+  context "running chef client" do
+    should "cd into the provisioning directory and run chef client" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json").once
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.run_chef_client
+    end
+  end
+end

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -0,0 +1,142 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ChefSoloProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action = Vagrant::Provisioners::ChefSolo.new
+
+    Vagrant::SSH.stubs(:execute)
+    Vagrant::SSH.stubs(:upload!)
+
+    mock_config
+  end
+
+  context "preparing" do
+    should "share cookbook folders" do
+      @action.expects(:share_cookbook_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(: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|
+        Vagrant.config.vm.expects(:share_folder).with("vagrant-chef-solo-#{i}", @action.cookbook_path(i), cookbook).in_sequence(share_seq)
+      end
+
+      @action.share_cookbook_folders
+    end
+  end
+
+  context "host cookbooks paths" do
+    should "expand the path of the cookbooks relative to the environment root path" do
+      @cookbook = "foo"
+      @expanded = "bar"
+      File.expects(:expand_path).with(@cookbook, Vagrant::Env.root_path).returns(@expanded)
+
+      mock_config do |config|
+        config.chef.cookbooks_path = @cookbook
+      end
+
+      assert_equal [@expanded], @action.host_cookbook_paths
+    end
+
+    should "return as an array if was originally a string" do
+      File.stubs(:expand_path).returns("foo")
+
+      mock_config do |config|
+        config.chef.cookbooks_path = "foo"
+      end
+
+      assert_equal ["foo"], @action.host_cookbook_paths
+    end
+
+    should "return the array of cookbooks if its an array" do
+      cookbooks = ["foo", "bar"]
+      mock_config do |config|
+        config.chef.cookbooks_path = cookbooks
+      end
+
+      expand_seq = sequence('expand_seq')
+      cookbooks.each do |cookbook|
+        File.expects(:expand_path).with(cookbook, Vagrant::Env.root_path).returns(cookbook)
+      end
+
+      assert_equal cookbooks, @action.host_cookbook_paths
+    end
+  end
+
+  context "cookbooks path" do
+    should "return a proper path to a single cookbook" do
+      expected = File.join(Vagrant.config.chef.provisioning_path, "cookbooks-5")
+      assert_equal expected, @action.cookbook_path(5)
+    end
+
+    should "return array-representation of cookbook paths if multiple" do
+      @cookbooks = (0..5).inject([]) do |acc, i|
+        acc << @action.cookbook_path(i)
+      end
+
+      mock_config do |config|
+        config.chef.cookbooks_path = @cookbooks
+      end
+
+      assert_equal @cookbooks.to_json, @action.cookbooks_path
+    end
+
+    should "return a single string representation if cookbook paths is single" do
+      @cookbooks = @action.cookbook_path(0)
+
+      mock_config do |config|
+        config.chef.cookbooks_path = @cookbooks
+      end
+
+      assert_equal @cookbooks.to_json, @action.cookbooks_path
+    end
+  end
+
+  context "generating and uploading chef solo configuration file" do
+    should "upload properly generate the configuration file using configuration data" do
+      expected_config = <<-config
+file_cache_path "#{Vagrant.config.chef.provisioning_path}"
+cookbook_path #{@action.cookbooks_path}
+config
+
+      StringIO.expects(:new).with(expected_config).once
+      @action.setup_solo_config
+    end
+
+    should "upload this file as solo.rb to the provisioning folder" do
+      @action.expects(:cookbooks_path).returns("cookbooks")
+      StringIO.expects(:new).returns("foo")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "solo.rb").once.returns("bar")
+      Vagrant::SSH.expects(:upload!).with("foo", "bar").once
+      @action.setup_solo_config
+    end
+  end
+
+  context "running chef solo" do
+    should "cd into the provisioning directory and run chef solo" do
+      ssh = mock("ssh")
+      ssh.expects(:exec!).with("cd #{Vagrant.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.run_chef_solo
+    end
+  end
+end

data/test/vagrant/provisioners/chef_test.rb

@@ -0,0 +1,116 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'test_helper')
+
+class ChefProvisionerTest < Test::Unit::TestCase
+  setup do
+    @action = Vagrant::Provisioners::Chef.new
+
+    Vagrant::SSH.stubs(:execute)
+    Vagrant::SSH.stubs(:upload!)
+
+    mock_config
+  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 "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 #{Vagrant.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
+      ssh.expects(:exec!).with("sudo chown #{Vagrant.config.ssh.username} #{Vagrant.config.chef.provisioning_path}").once.in_sequence(ssh_seq)
+      Vagrant::SSH.expects(:execute).yields(ssh)
+      @action.chown_provisioning_folder
+    end
+  end
+
+  context "generating and uploading json" do
+    def assert_json
+      Vagrant::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
+      Vagrant.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 Vagrant.config.vm.project_directory, data["vagrant"]["directory"]
+      end
+    end
+
+    should "add the config to the JSON" do
+      assert_json do |data|
+        assert_equal Vagrant.config.vm.project_directory, data["vagrant"]["config"]["vm"]["project_directory"]
+      end
+    end
+
+    should "upload a StringIO to dna.json" do
+      StringIO.expects(:new).with(anything).returns("bar")
+      File.expects(:join).with(Vagrant.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      Vagrant::SSH.expects(:upload!).with("bar", "baz").once
+      @action.setup_json
+    end
+  end
+end

data/test/vagrant/ssh_test.rb

@@ -6,21 +6,31 @@ class SshTest < Test::Unit::TestCase
   end
 
   context "connecting to SSH" do
-    setup do
-      @script = Vagrant::SSH::SCRIPT
-    end
-
     test "should call exec with defaults when no options are supplied" do
       ssh = Vagrant.config.ssh
-      Kernel.expects(:exec).with("#{@script} #{ssh[:username]} #{ssh[:password]} #{ssh[:host]} #{Vagrant::SSH.port}")
+      ssh_exec_expect(Vagrant::SSH.port,
+                      Vagrant.config.ssh.private_key_path,
+                      Vagrant.config.ssh.username,
+                      Vagrant.config.ssh.host)
       Vagrant::SSH.connect
     end
 
     test "should call exec with supplied params" do
-      args = {:username => 'bar', :password => 'baz', :host => 'bak', :port => 'bag'}
-      Kernel.expects(:exec).with("#{@script} #{args[:username]} #{args[:password]} #{args[:host]} #{args[:port]}")
+      args = {:username => 'bar', :private_key_path => 'baz', :host => 'bak', :port => 'bag'}
+      ssh_exec_expect(args[:port], args[:private_key_path], args[:username], args[:host])
       Vagrant::SSH.connect(args)
     end
+
+    def ssh_exec_expect(port, key_path, uname, host)
+    Kernel.expects(:exec).with() do |arg|
+        assert arg =~ /^ssh/
+        assert arg =~ /-p #{port}/
+        assert arg =~ /-i #{key_path}/
+        assert arg =~ /#{uname}@#{host}/
+        # TODO options not tested for as they may be removed, they may be removed
+        true
+      end
+    end
   end
 
   context "executing ssh commands" do
@@ -29,7 +39,7 @@ class SshTest < Test::Unit::TestCase
         assert_equal Vagrant.config.ssh.host, host
         assert_equal Vagrant.config.ssh.username, username
         assert_equal Vagrant::SSH.port, opts[:port]
-        assert_equal Vagrant.config.ssh.password, opts[:password]
+        assert_equal [Vagrant.config.ssh.private_key_path], opts[:keys]
         true
       end
       Vagrant::SSH.execute
@@ -89,6 +99,17 @@ class SshTest < Test::Unit::TestCase
         assert !Vagrant::SSH.up?
       }
     end
+
+    should "specifity the timeout as an option to execute" do
+      Vagrant::SSH.expects(:execute).with(:timeout => Vagrant.config.ssh.timeout).yields(true)
+      assert Vagrant::SSH.up?
+    end
+
+    should "error and exit if a Net::SSH::AuthenticationFailed is raised" do
+      Vagrant::SSH.expects(:execute).raises(Net::SSH::AuthenticationFailed)
+      Vagrant::SSH.expects(:error_and_exit).once
+      Vagrant::SSH.up?
+    end
   end
 
   context "getting the ssh port" do