vagrantup 0.2.0 → 0.3.0

data/test/vagrant/provisioners/base_test.rb

@@ -7,7 +7,13 @@ class BaseProvisionerTest < Test::Unit::TestCase
 
   context "base instance" do
     setup do
-      @base = Vagrant::Provisioners::Base.new
+      @env = mock_environment
+      @base = Vagrant::Provisioners::Base.new(@env)
+    end
+
+    should "set the environment" do
+      base = Vagrant::Provisioners::Base.new(@env)
+      assert_equal @env, base.env
     end
 
     should "implement provision! which does nothing" do

data/test/vagrant/provisioners/chef_server_test.rb

@@ -2,12 +2,8 @@ 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
+    @env = mock_environment
+    @action = Vagrant::Provisioners::ChefServer.new(@env)
   end
 
   context "provisioning" do
@@ -17,7 +13,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
       @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(:setup_server_config).once.in_sequence(prov_seq)
       @action.expects(:run_chef_client).once.in_sequence(prov_seq)
       @action.provision!
     end
@@ -29,56 +25,70 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
     end
 
     should "not raise an exception if validation_key_path is set" do
-      mock_config do |config|
+      @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
-      mock_config do |config|
+      @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
-      mock_config do |config|
+      @env = mock_environment do |config|
         config.chef.validation_key_path = "7"
       end
 
-      File.expects(:file?).with(Vagrant.config.chef.validation_key_path).returns(true)
+      @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
-      mock_config do |config|
+      @env = mock_environment do |config|
         config.chef.validation_key_path = "7"
       end
 
-      File.expects(:file?).with(Vagrant.config.chef.validation_key_path).returns(false)
+      @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
-      mock_config do |config|
+      @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
-      mock_config do |config|
+      @env = mock_environment do |config|
         config.chef.chef_server_url = nil
       end
 
+      @action.stubs(:env).returns(@env)
+
       assert_raises(Vagrant::Actions::ActionException) {
         @action.prepare
       }
@@ -88,9 +98,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
   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
+      @env.config.chef.client_key_path = @raw_path
 
       @path = Pathname.new(@raw_path)
     end
@@ -98,7 +106,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
     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)
+      @env.ssh.expects(:execute).yields(ssh)
       @action.create_client_key_folder
     end
   end
@@ -107,7 +115,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
     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
+      @env.ssh.expects(:upload!).with("foo", "bar").once
       @action.upload_validation_key
     end
   end
@@ -115,7 +123,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
   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)
+      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
@@ -123,7 +131,7 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
   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)
+      File.expects(:join).with(@env.config.chef.provisioning_path, "validation.pem").once.returns(result)
       assert_equal result, @action.guest_validation_key_path
     end
   end
@@ -133,42 +141,24 @@ class ChefServerProvisionerTest < Test::Unit::TestCase
       @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 "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
+      })
 
-    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
+      @action.setup_server_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)
+      ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-client -c client.rb -j dna.json").once
+      @env.ssh.expects(:execute).yields(ssh)
       @action.run_chef_client
     end
   end

data/test/vagrant/provisioners/chef_solo_test.rb

@@ -2,12 +2,8 @@ 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
+    @env = mock_environment
+    @action = Vagrant::Provisioners::ChefSolo.new(@env)
   end
 
   context "preparing" do
@@ -15,6 +11,11 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
       @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
@@ -37,96 +38,126 @@ class ChefSoloProvisionerTest < Test::Unit::TestCase
     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)
+        @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 "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)
+  context "sharing role folders" do
+    setup do
+      @host_role_paths = ["foo", "bar"]
+      @action.stubs(:host_role_paths).returns(@host_role_paths)
+    end
 
-      mock_config do |config|
-        config.chef.cookbooks_path = @cookbook
+    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
 
-      assert_equal [@expanded], @action.host_cookbook_paths
+      @action.share_role_folders
     end
+  end
 
+  context "host folder paths" do
     should "return as an array if was originally a string" do
-      File.stubs(:expand_path).returns("foo")
+      folder = "foo"
+      File.stubs(:expand_path).returns("bar")
+      assert_equal ["bar"], @action.host_folder_paths(folder)
+    end
 
-      mock_config do |config|
-        config.chef.cookbooks_path = "foo"
-      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 ["foo"], @action.host_cookbook_paths
+      assert_equal folders, @action.host_folder_paths(folders)
     end
+  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
+  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
 
-      assert_equal cookbooks, @action.host_cookbook_paths
+  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 "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)
+  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 cookbook paths if multiple" do
-      @cookbooks = (0..5).inject([]) do |acc, i|
+    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
 
-      mock_config do |config|
-        config.chef.cookbooks_path = @cookbooks
-      end
+      assert_equal @cookbooks.to_json, @action.folders_path(@folders, "cookbooks")
+    end
 
-      assert_equal @cookbooks.to_json, @action.cookbooks_path
+    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 "return a single string representation if cookbook paths is single" do
-      @cookbooks = @action.cookbook_path(0)
+    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
 
-      mock_config do |config|
-        config.chef.cookbooks_path = @cookbooks
-      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
 
-      assert_equal @cookbooks.to_json, @action.cookbooks_path
+    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
-    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
+    setup do
+      @env.ssh.stubs(:upload!)
     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
+    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
@@ -134,8 +165,8 @@ config
   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)
+      ssh.expects(:exec!).with("cd #{@env.config.chef.provisioning_path} && sudo chef-solo -c solo.rb -j dna.json").once
+      @env.ssh.expects(:execute).yields(ssh)
       @action.run_chef_solo
     end
   end

data/test/vagrant/provisioners/chef_test.rb

@@ -2,12 +2,8 @@ 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
+    @env = mock_environment
+    @action = Vagrant::Provisioners::Chef.new(@env)
   end
 
   context "preparing" do
@@ -69,16 +65,66 @@ class ChefProvisionerTest < Test::Unit::TestCase
     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)
+      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)
+      @env.ssh.expects(:execute).yields(ssh)
       @action.chown_provisioning_folder
     end
   end
 
+  context "generating and uploading chef configuration file" do
+    setup do
+      @env.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")
+      @env.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
-      Vagrant::SSH.expects(:upload!).with do |json, path|
+      @env.ssh.expects(:upload!).with do |json, path|
         data = JSON.parse(json.read)
         yield data
         true
@@ -88,7 +134,7 @@ class ChefProvisionerTest < Test::Unit::TestCase
     end
 
     should "merge in the extra json specified in the config" do
-      Vagrant.config.chef.json = { :foo => "BAR" }
+      @env.config.chef.json = { :foo => "BAR" }
       assert_json do |data|
         assert_equal "BAR", data["foo"]
       end
@@ -96,20 +142,20 @@ class ChefProvisionerTest < Test::Unit::TestCase
 
     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"]
+        assert_equal @env.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"]
+        assert_equal @env.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
+      File.expects(:join).with(@env.config.chef.provisioning_path, "dna.json").once.returns("baz")
+      @env.ssh.expects(:upload!).with("bar", "baz").once
       @action.setup_json
     end
   end