chef 12.0.0.alpha.0 → 12.0.0.alpha.1

data/spec/support/shared/integration/knife_support.rb

@@ -63,7 +63,6 @@ module KnifeSupport
         Chef::Config[:verbosity] = ( DEBUG ? 2 : 0 )
         instance.config[:config_file] = File.join(CHEF_SPEC_DATA, "null_config.rb")
 
-
         # Configure chef with a (mostly) blank knife.rb
         # We set a global and then mutate it in our stub knife.rb so we can be
         # extra sure that we're not loading someone's real knife.rb and then

data/spec/support/shared/unit/provider/file.rb

@@ -460,17 +460,19 @@ shared_examples_for Chef::Provider::File do
       context "when the file exists" do
         before { setup_normal_file }
         it "should not create the file" do
+          provider.load_current_resource
           provider.deployment_strategy.should_not_receive(:create).with(resource_path)
           provider.send(:do_create_file)
-          provider.send(:file_created?).should == false
+          provider.send(:needs_creating?).should == false
         end
       end
       context "when the file does not exist" do
         before { setup_missing_file }
         it "should create the file" do
+          provider.load_current_resource
           provider.deployment_strategy.should_receive(:create).with(resource_path)
           provider.send(:do_create_file)
-          provider.send(:file_created?).should == true
+          provider.send(:needs_creating?).should == true
         end
       end
     end
@@ -503,7 +505,7 @@ shared_examples_for Chef::Provider::File do
             provider.deployment_strategy.should_receive(:deploy).with(tempfile_path, normalized_path)
           end
           context "when the file was created" do
-            before { provider.should_receive(:file_created?).at_least(:once).and_return(true) }
+            before { provider.should_receive(:needs_creating?).at_least(:once).and_return(true) }
             it "does not backup the file and does not produce a diff for reporting" do
               provider.should_not_receive(:do_backup)
               provider.send(:do_contents_changes)
@@ -511,7 +513,7 @@ shared_examples_for Chef::Provider::File do
             end
           end
           context "when the file was not created" do
-            before { provider.should_receive(:file_created?).at_least(:once).and_return(false) }
+            before { provider.should_receive(:needs_creating?).at_least(:once).and_return(false) }
             it "backs up the file and produces a diff for reporting" do
               provider.should_receive(:do_backup)
               provider.send(:do_contents_changes)

data/spec/support/shared/unit/provider/useradd_based_user_provider.rb

@@ -33,6 +33,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     @new_resource.password "abracadabra"
     @new_resource.system false
     @new_resource.manage_home false
+    @new_resource.force false
     @new_resource.non_unique false
     @current_resource = Chef::Resource::User.new("adam", @run_context)
     @current_resource.comment "Adam Jacob"
@@ -43,6 +44,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
     @current_resource.password "abracadabra"
     @current_resource.system false
     @current_resource.manage_home false
+    @current_resource.force false
     @current_resource.non_unique false
     @current_resource.supports({:manage_home => false, :non_unique => false})
   end
@@ -71,6 +73,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
       it "should set the option for #{attribute} if the new resources #{attribute} is not nil, without homedir management (using real attributes)" do
         @new_resource.stub(:manage_home).and_return(false)
         @new_resource.stub(:non_unique).and_return(false)
+        @new_resource.stub(:non_unique).and_return(false)
         @new_resource.stub(attribute).and_return("hola")
         provider.universal_options.should eql([option, 'hola'])
       end
@@ -255,6 +258,12 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
       provider.should_receive(:shell_out!).with("userdel", @new_resource.username).and_return(true)
       provider.remove_user
     end
+
+    it "should run userdel with the new resources user name and -f if force is true" do
+      @new_resource.force(true)
+      provider.should_receive(:shell_out!).with("userdel", "-f", @new_resource.username).and_return(true)
+      provider.remove_user
+    end
   end
 
   describe "when checking the lock" do
@@ -344,7 +353,7 @@ shared_examples_for "a useradd-based user provider" do |supported_useradd_option
           and_return(passwd_status)
         Chef::Config[:why_run] = true
       end
-  
+
       it "should return false if the user does not exist" do
         provider.check_lock.should eql(false)
       end

data/spec/unit/api_client/registration_spec.rb

@@ -38,11 +38,11 @@ describe Chef::ApiClient::Registration do
   let(:http_mock) { double("Chef::REST mock") }
 
   let(:expected_post_data) do
-    { :name => client_name, :admin => false }
+    { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
   end
 
   let(:expected_put_data) do
-    { :name => client_name, :admin => false, :private_key => true }
+    { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
   end
 
   let(:server_v10_response) do
@@ -61,9 +61,31 @@ describe Chef::ApiClient::Registration do
   let(:response_409) { Net::HTTPConflict.new("1.1", "409", "Conflict") }
   let(:exception_409) { Net::HTTPServerException.new("409 conflict", response_409) }
 
+  let(:generated_private_key_pem) { IO.read(File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)) }
+  let(:generated_private_key) { OpenSSL::PKey::RSA.new(generated_private_key_pem) }
+  let(:generated_public_key) { generated_private_key.public_key }
+
+
+  let(:create_with_pkey_response) do
+    {
+      "uri" => "",
+      "public_key" => generated_public_key.to_pem
+    }
+  end
+
+  let(:update_with_pkey_response) do
+    {"name"=>client_name,
+     "admin"=>false,
+     "public_key"=> generated_public_key,
+     "validator"=>false,
+     "private_key"=>false,
+     "clientname"=>client_name}
+  end
+
   before do
     Chef::Config[:validation_client_name] = "test-validator"
     Chef::Config[:validation_key] = File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)
+    OpenSSL::PKey::RSA.stub(:generate).with(2048).and_return(generated_private_key)
   end
 
   after do
@@ -81,74 +103,6 @@ describe Chef::ApiClient::Registration do
       registration.stub(:http_api).and_return(http_mock)
     end
 
-    it "creates a new ApiClient on the server using the validator identity" do
-      http_mock.should_receive(:post).
-        with("clients", expected_post_data).
-        and_return(server_v10_response)
-      registration.create_or_update.should == server_v10_response
-      registration.private_key.should == "--begin rsa key etc--"
-    end
-
-    context "and the client already exists on a Chef 10 server" do
-      it "requests a new key from the server and saves it" do
-        http_mock.should_receive(:post).with("clients", expected_post_data).
-          and_raise(exception_409)
-        http_mock.should_receive(:put).
-          with("clients/#{client_name}", expected_put_data).
-          and_return(server_v10_response)
-        registration.create_or_update.should == server_v10_response
-        registration.private_key.should == "--begin rsa key etc--"
-      end
-    end
-
-    context "and the client already exists on a Chef 11 server" do
-      it "requests a new key from the server and saves it" do
-        http_mock.should_receive(:post).and_raise(exception_409)
-        http_mock.should_receive(:put).
-          with("clients/#{client_name}", expected_put_data).
-          and_return(server_v11_response)
-        registration.create_or_update.should == server_v11_response
-        registration.private_key.should == "--begin rsa key etc--"
-      end
-    end
-  end
-
-  context "when local key generation is enabled", :nofocus do
-    let(:generated_private_key_pem) { IO.read(File.expand_path('ssl/private_key.pem', CHEF_SPEC_DATA)) }
-    let(:generated_private_key) { OpenSSL::PKey::RSA.new(generated_private_key_pem) }
-    let(:generated_public_key) { generated_private_key.public_key }
-
-    let(:expected_post_data) do
-      { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
-    end
-
-    let(:expected_put_data) do
-      { :name => client_name, :admin => false, :public_key => generated_public_key.to_pem }
-    end
-
-    let(:create_with_pkey_response) do
-      {
-        "uri" => "",
-        "public_key" => generated_public_key.to_pem
-      }
-    end
-
-    let(:update_with_pkey_response) do
-      {"name"=>client_name,
-       "admin"=>false,
-       "public_key"=> generated_public_key,
-       "validator"=>false,
-       "private_key"=>false,
-       "clientname"=>client_name}
-    end
-
-
-    before do
-      registration.stub(:http_api).and_return(http_mock)
-      Chef::Config.local_key_generation = true
-      OpenSSL::PKey::RSA.should_receive(:generate).with(2048).and_return(generated_private_key)
-    end
-
     it "posts a locally generated public key to the server to create a client" do
       http_mock.should_receive(:post).
         with("clients", expected_post_data).
@@ -176,6 +130,63 @@ describe Chef::ApiClient::Registration do
       IO.read(key_location).should == generated_private_key_pem
     end
 
+    context "and the client already exists on a Chef 11 server" do
+      it "requests a new key from the server and saves it" do
+        http_mock.should_receive(:post).and_raise(exception_409)
+        http_mock.should_receive(:put).
+          with("clients/#{client_name}", expected_put_data).
+          and_return(update_with_pkey_response)
+        registration.create_or_update.should == update_with_pkey_response
+        registration.private_key.should == generated_private_key_pem
+      end
+    end
+
+    context "when local key generation is disabled" do
+
+      let(:expected_post_data) do
+        { :name => client_name, :admin => false }
+      end
+
+      let(:expected_put_data) do
+        { :name => client_name, :admin => false, :private_key => true }
+      end
+
+      before do
+        Chef::Config[:local_key_generation] = false
+        OpenSSL::PKey::RSA.should_not_receive(:generate)
+      end
+
+      it "creates a new ApiClient on the server using the validator identity" do
+        http_mock.should_receive(:post).
+          with("clients", expected_post_data).
+          and_return(server_v10_response)
+        registration.create_or_update.should == server_v10_response
+        registration.private_key.should == "--begin rsa key etc--"
+      end
+
+      context "and the client already exists on a Chef 11 server" do
+        it "requests a new key from the server and saves it" do
+          http_mock.should_receive(:post).and_raise(exception_409)
+          http_mock.should_receive(:put).
+            with("clients/#{client_name}", expected_put_data).
+            and_return(server_v11_response)
+          registration.create_or_update.should == server_v11_response
+          registration.private_key.should == "--begin rsa key etc--"
+        end
+      end
+
+      context "and the client already exists on a Chef 10 server" do
+        it "requests a new key from the server and saves it" do
+          http_mock.should_receive(:post).with("clients", expected_post_data).
+            and_raise(exception_409)
+          http_mock.should_receive(:put).
+            with("clients/#{client_name}", expected_put_data).
+            and_return(server_v10_response)
+          registration.create_or_update.should == server_v10_response
+          registration.private_key.should == "--begin rsa key etc--"
+        end
+      end
+    end
   end
 
   describe "when writing the private key to disk" do
@@ -209,7 +220,7 @@ describe Chef::ApiClient::Registration do
     it "creates the client on the server and writes the key" do
       http_mock.should_receive(:post).ordered.and_return(server_v10_response)
       registration.run
-      IO.read(key_location).should == "--begin rsa key etc--"
+      IO.read(key_location).should == generated_private_key_pem
     end
 
     it "retries up to 5 times" do
@@ -224,7 +235,7 @@ describe Chef::ApiClient::Registration do
 
       http_mock.should_receive(:post).ordered.and_return(server_v10_response)
       registration.run
-      IO.read(key_location).should == "--begin rsa key etc--"
+      IO.read(key_location).should == generated_private_key_pem
     end
 
     it "gives up retrying after the max attempts" do
@@ -239,5 +250,3 @@ describe Chef::ApiClient::Registration do
   end
 
 end
-
-

data/spec/unit/application_spec.rb

@@ -255,7 +255,12 @@ describe Chef::Application do
 
       it "should set ENV['http_proxy']" do
         @app.configure_proxy_environment_variables
-        @env['http_proxy'].should == "http://#{address}:#{port}"
+        @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
+      end
+
+      it "should set ENV['HTTP_PROXY']" do
+        @app.configure_proxy_environment_variables
+        @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
       end
 
       describe "when Chef::Config[:http_proxy_user] is set" do
@@ -265,7 +270,8 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy'] with the username" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "http://username@#{address}:#{port}"
+          @env['http_proxy'].should == "#{scheme}://username@#{address}:#{port}"
+          @env['HTTP_PROXY'].should == "#{scheme}://username@#{address}:#{port}"
         end
 
         context "when :http_proxy_user contains '@' and/or ':'" do
@@ -275,7 +281,8 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the escaped username" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "http://my%3Ausern%40me@#{address}:#{port}"
+            @env['http_proxy'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
+            @env['HTTP_PROXY'].should == "#{scheme}://my%3Ausern%40me@#{address}:#{port}"
           end
         end
 
@@ -286,7 +293,8 @@ describe Chef::Application do
 
           it "should set ENV['http_proxy'] with the password" do
             @app.configure_proxy_environment_variables
-            @env['http_proxy'].should == "http://username:password@#{address}:#{port}"
+            @env['http_proxy'].should == "#{scheme}://username:password@#{address}:#{port}"
+            @env['HTTP_PROXY'].should == "#{scheme}://username:password@#{address}:#{port}"
           end
 
           context "when :http_proxy_pass contains '@' and/or ':'" do
@@ -296,7 +304,8 @@ describe Chef::Application do
 
             it "should set ENV['http_proxy'] with the escaped password" do
               @app.configure_proxy_environment_variables
-              @env['http_proxy'].should == "http://username:%3AP%40ssword101@#{address}:#{port}"
+              @env['http_proxy'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
+              @env['HTTP_PROXY'].should == "#{scheme}://username:%3AP%40ssword101@#{address}:#{port}"
             end
           end
         end
@@ -310,7 +319,8 @@ describe Chef::Application do
 
         it "should set ENV['http_proxy']" do
           @app.configure_proxy_environment_variables
-          @env['http_proxy'].should == "http://#{address}:#{port}"
+          @env['http_proxy'].should == "#{scheme}://#{address}:#{port}"
+          @env['HTTP_PROXY'].should == "#{scheme}://#{address}:#{port}"
         end
       end
     end
@@ -338,30 +348,43 @@ describe Chef::Application do
 
       describe "when Chef::Config[:http_proxy] is set" do
         context "when given an FQDN" do
+          let(:scheme) { "http" }
+          let(:address) { "proxy.example.org" }
+          let(:port) { 8080 }
+          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
+
+          it_should_behave_like "setting ENV['http_proxy']"
+        end
+
+        context "when given an HTTPS URL" do
+          let(:scheme) { "https" }
           let(:address) { "proxy.example.org" }
           let(:port) { 8080 }
-          let(:http_proxy) { "http://#{address}:#{port}" }
+          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given an IP" do
+          let(:scheme) { "http" }
           let(:address) { "127.0.0.1" }
           let(:port) { 22 }
-          let(:http_proxy) { "http://#{address}:#{port}" }
+          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given an IPv6" do
+          let(:scheme) { "http" }
           let(:address) { "[2001:db8::1]" }
           let(:port) { 80 }
-          let(:http_proxy) { "http://#{address}:#{port}" }
+          let(:http_proxy) { "#{scheme}://#{address}:#{port}" }
 
           it_should_behave_like "setting ENV['http_proxy']"
         end
 
         context "when given without including http://" do
+          let(:scheme) { "http" }
           let(:address) { "proxy.example.org" }
           let(:port) { 8181 }
           let(:http_proxy) { "#{address}:#{port}" }

data/spec/unit/cookbook/cookbook_version_loader_spec.rb

@@ -0,0 +1,179 @@
+#
+# Author:: Daniel DeLeo (<dan@getchef.com>)
+# Copyright:: Copyright (c) 2014 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+
+describe Chef::Cookbook::CookbookVersionLoader do
+
+  describe "loading a cookbook" do
+
+    let(:chefignore) { nil }
+
+    let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/openldap") }
+
+    let(:cookbook_loader) { Chef::Cookbook::CookbookVersionLoader.new(cookbook_path, chefignore) }
+
+    let(:loaded_cookbook) do
+      cookbook_loader.load!
+      cookbook_loader.cookbook_version
+    end
+
+    def full_path(cookbook_relative_path)
+      File.join(cookbook_path, cookbook_relative_path)
+    end
+
+    it "loads attribute files of the cookbook" do
+      expect(loaded_cookbook.attribute_filenames).to include(full_path("/attributes/default.rb"))
+      expect(loaded_cookbook.attribute_filenames).to include(full_path("/attributes/smokey.rb"))
+    end
+
+    it "loads definition files" do
+      expect(loaded_cookbook.definition_filenames).to include(full_path("/definitions/client.rb"))
+      expect(loaded_cookbook.definition_filenames).to include(full_path("/definitions/server.rb"))
+    end
+
+    it "loads recipes" do
+      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/default.rb"))
+      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/gigantor.rb"))
+      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/one.rb"))
+      expect(loaded_cookbook.recipe_filenames).to include(full_path("/recipes/return.rb"))
+    end
+
+    it "loads static files in the files/ dir" do
+      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file1.txt"))
+      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file2.txt"))
+    end
+
+    it "loads files that start with a ." do
+      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/.dotfile"))
+      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/.ssh/id_rsa"))
+      expect(loaded_cookbook.file_filenames).to include(full_path("/files/default/remotedir/.a_dotdir/.a_dotfile_in_a_dotdir"))
+    end
+
+    it "should load the metadata for the cookbook" do
+      loaded_cookbook.metadata.name.to_s.should == "openldap"
+      loaded_cookbook.metadata.should be_a_kind_of(Chef::Cookbook::Metadata)
+    end
+
+    context "when a cookbook has ignored files" do
+
+      let(:chefignore) { Chef::Cookbook::Chefignore.new(File.join(CHEF_SPEC_DATA, "cookbooks")) }
+
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "kitchen/openldap") }
+
+      it "skips ignored files" do
+        expect(loaded_cookbook.recipe_filenames).to include(full_path("recipes/gigantor.rb"))
+        expect(loaded_cookbook.recipe_filenames).to include(full_path("recipes/woot.rb"))
+        expect(loaded_cookbook.recipe_filenames).to_not include(full_path("recipes/ignoreme.rb"))
+      end
+
+    end
+
+    context "when the given path is not actually a cookbook" do
+
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/NOTHING_HERE_FOLKS") }
+
+      it "raises an error when loading with #load!" do
+        expect { cookbook_loader.load! }.to raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
+      end
+
+      it "skips the cookbook when called with #load" do
+        expect { cookbook_loader.load }.to_not raise_error
+      end
+
+    end
+
+    context "when a cookbook has a metadata name different than directory basename" do
+
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/name-mismatch-versionnumber") }
+
+      it "prefers the metadata name to the directory basename" do
+        expect(loaded_cookbook.name).to eq(:"name-mismatch")
+      end
+
+    end
+
+    context "when a cookbook has a metadata file with a ruby error [CHEF-2923]" do
+
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo/invalid-metadata") }
+
+      it "raises an error when loading with #load!" do
+        expect { cookbook_loader.load! }.to raise_error("THIS METADATA HAS A BUG")
+      end
+
+      it "raises an error when called with #load" do
+        expect { cookbook_loader.load }.to raise_error("THIS METADATA HAS A BUG")
+      end
+
+      it "doesn't raise an error when determining the cookbook name" do
+        expect { cookbook_loader.cookbook_name }.to_not raise_error
+      end
+
+      it "doesn't raise an error when metadata is first generated" do
+        expect { cookbook_loader.metadata }.to_not raise_error
+      end
+
+      it "sets an error flag containing error information" do
+        cookbook_loader.metadata
+        expect(cookbook_loader.metadata_error).to be_a(StandardError)
+        expect(cookbook_loader.metadata_error.message).to eq("THIS METADATA HAS A BUG")
+      end
+
+    end
+
+    context "when a cookbook has a metadata file with invalid metadata" do
+
+      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "incomplete-metadata-chef-repo/incomplete-metadata") }
+
+      let(:error_message) do
+        "Cookbook loaded at path(s) [#{cookbook_path}] has invalid metadata: The `name' attribute is required in cookbook metadata"
+      end
+
+      it "raises an error when loading with #load!" do
+        expect { cookbook_loader.load! }.to raise_error(Chef::Exceptions::MetadataNotValid, error_message)
+      end
+
+      it "raises an error when called with #load" do
+        expect { cookbook_loader.load }.to raise_error(Chef::Exceptions::MetadataNotValid, error_message)
+      end
+
+      it "uses the inferred cookbook name [CHEF-2923]" do
+        # This behavior is intended to support the CHEF-2923 feature where
+        # invalid metadata doesn't prevent you from uploading other cookbooks.
+        #
+        # The metadata is the definitive source of the cookbook name, but if
+        # the metadata is incomplete/invalid, we can't read the name from it.
+        #
+        # The CookbookLoader stores CookbookVersionLoaders in a Hash with
+        # cookbook names as the keys, and finds the loader in this Hash to call
+        # #load on it when the user runs a command like `knife cookbook upload specific-cookbook`
+        #
+        # Most of the time this will work, but if the user tries to upload a
+        # specific cookbook by name, has customized that cookbook's name (so it
+        # doesn't match the inferred name), and that metadata file has a syntax
+        # error, we might report a "cookbook not found" error instead of the
+        # metadata syntax error that is the actual cause.
+        expect(cookbook_loader.cookbook_name).to eq(:"incomplete-metadata")
+      end
+
+    end
+
+  end
+
+end
+