chef 11.10.4-x86-mingw32 → 11.12.0.alpha.1-x86-mingw32

data/spec/unit/cookbook/syntax_check_spec.rb

@@ -28,7 +28,6 @@ describe Chef::Cookbook::SyntaxCheck do
     Chef::Log.logger = Logger.new(StringIO.new)
     Chef::Log.level = :warn # suppress "Syntax OK" messages
 
-
     @attr_files = %w{default.rb smokey.rb}.map { |f| File.join(cookbook_path, 'attributes', f) }
     @defn_files = %w{client.rb server.rb}.map { |f| File.join(cookbook_path, 'definitions', f)}
     @recipes = %w{default.rb gigantor.rb one.rb}.map { |f| File.join(cookbook_path, 'recipes', f) }

data/spec/unit/dsl/reboot_pending_spec.rb

@@ -0,0 +1,100 @@
+#
+# Author:: Bryan McLellan <btm@loftninjas.org>
+# 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 "chef/dsl/reboot_pending"
+require "spec_helper"
+
+describe Chef::DSL::RebootPending do
+  describe "reboot_pending?" do
+    describe "in isoloation" do
+      let(:recipe) { Object.new.extend(Chef::DSL::RebootPending) }
+
+      before do
+        recipe.stub(:platform?).and_return(false)
+      end
+
+      context "platform is windows" do
+        before do
+          recipe.stub(:platform?).with('windows').and_return(true)
+          recipe.stub(:registry_key_exists?).and_return(false)
+          recipe.stub(:registry_value_exists?).and_return(false)
+        end
+  
+        it 'should return true if "HKLM\SYSTEM\CurrentControlSet\Control\Session Manager\PendingFileRenameOperations" exists' do
+          recipe.stub(:registry_value_exists?).with('HKLM\SYSTEM\CurrentControlSet\Control\Session Manager', { :name => 'PendingFileRenameOperations' }).and_return(true)
+          expect(recipe.reboot_pending?).to be_true
+        end
+  
+        it 'should return true if "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired" exists' do
+          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired').and_return(true)
+          expect(recipe.reboot_pending?).to be_true
+        end
+  
+        it 'should return true if key "HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired" exists' do
+          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Component Based Servicing\RebootRequired').and_return(true)
+          expect(recipe.reboot_pending?).to be_true
+        end
+  
+        it 'should return true if value "HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile" contains specific data' do
+          recipe.stub(:registry_key_exists?).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(true)
+          recipe.stub(:registry_get_values).with('HKLM\SOFTWARE\Microsoft\Updates\UpdateExeVolatile').and_return(
+                [{:name => "Flags", :type => :dword, :data => 3}])
+          expect(recipe.reboot_pending?).to be_true
+        end
+      end
+  
+      context "platform is ubuntu" do
+        before do
+          recipe.stub(:platform?).with('ubuntu').and_return(true)
+        end
+  
+        it 'should return true if /var/run/reboot-required exists' do
+          File.stub(:exists?).with('/var/run/reboot-required').and_return(true)
+          expect(recipe.reboot_pending?).to be_true
+        end
+  
+        it 'should return false if /var/run/reboot-required does not exist' do
+          File.stub(:exists?).with('/var/run/reboot-required').and_return(false)
+          expect(recipe.reboot_pending?).to be_false
+        end
+      end
+
+      context "platform is not supported" do
+        it 'should raise an exception' do
+          recipe.stub_chain(:node, :[]).with(:platform).and_return('msdos')
+          expect { recipe.reboot_pending? }.to raise_error(Chef::Exceptions::UnsupportedPlatform)
+        end
+      end
+    end # describe in isolation
+
+    describe "in a recipe" do
+      it "responds to reboot_pending?" do
+        # Chef::Recipe.new(cookbook_name, recipe_name, run_context(node, cookbook_collection, events))
+        recipe = Chef::Recipe.new(nil,nil,Chef::RunContext.new(Chef::Node.new, {}, nil))
+        expect(recipe).to respond_to(:reboot_pending?)
+      end
+    end # describe in a recipe
+
+    describe "in a resource" do
+      it "responds to reboot_pending?" do
+        resource = Chef::Resource::new("Crackerjack::Timing", nil)
+        expect(resource).to respond_to(:reboot_pending?)
+      end
+    end # describe in a resource
+  end
+end

data/spec/unit/knife/client_create_spec.rb

@@ -25,7 +25,9 @@ describe Chef::Knife::ClientCreate do
     Chef::Config[:node_name]  = "webmonkey.example.com"
     @knife = Chef::Knife::ClientCreate.new
     @knife.config = {
-      :file => nil
+      :file => nil,
+      :admin => false,
+      :validator => false
     }
     @knife.name_args = [ "adam" ]
     @client = Chef::ApiClient.new
@@ -49,6 +51,16 @@ describe Chef::Knife::ClientCreate do
       @knife.run
     end
 
+    it "by default it is not an admin" do
+      @client.should_receive(:admin).with(false)
+      @knife.run
+    end
+
+    it "by default it is not a validator" do
+      @client.should_receive(:validator).with(false)
+      @knife.run
+    end
+
     it "should allow you to edit the data" do
       @knife.should_receive(:edit_data).with(@client)
       @knife.run
@@ -70,5 +82,21 @@ describe Chef::Knife::ClientCreate do
       end
     end
 
+    describe "with -a or --admin" do
+      it "should create an admin client" do
+        @knife.config[:admin] = true
+        @client.should_receive(:admin).with(true)
+        @knife.run
+      end
+    end
+
+    describe "with --validator" do
+      it "should create an validator client" do
+        @knife.config[:validator] = true
+        @client.should_receive(:validator).with(true)
+        @knife.run
+      end
+    end
+
   end
 end

data/spec/unit/knife/client_delete_spec.rb

@@ -21,12 +21,16 @@ require 'spec_helper'
 describe Chef::Knife::ClientDelete do
   before(:each) do
     @knife = Chef::Knife::ClientDelete.new
+    # defaults
+    @knife.config = {
+      :force => false
+    }
     @knife.name_args = [ 'adam' ]
   end
 
   describe 'run' do
     it 'should delete the client' do
-      @knife.should_receive(:delete_object).with(Chef::ApiClient, 'adam')
+      @knife.should_receive(:delete_object).with(Chef::ApiClient, 'adam', 'client')
       @knife.run
     end
 
@@ -37,4 +41,43 @@ describe Chef::Knife::ClientDelete do
       lambda { @knife.run }.should raise_error(SystemExit)
     end
   end
+
+  describe 'with a validator' do
+    before(:each) do
+      Chef::Knife::UI.stub(:confirm).and_return(true)
+      @knife.stub(:confirm).and_return(true)
+      @client = Chef::ApiClient.new
+      Chef::ApiClient.should_receive(:load).and_return(@client)
+    end
+
+    it 'should delete non-validator client if --force is not set' do
+      @knife.config[:force] = false
+      @client.should_receive(:destroy).and_return(@client)
+      @knife.should_receive(:msg)
+
+      @knife.run
+    end
+
+    it 'should delete non-validator client if --force is set' do
+      @knife.config[:force] = true
+      @client.should_receive(:destroy).and_return(@client)
+      @knife.should_receive(:msg)
+
+      @knife.run
+    end
+
+    it 'should not delete validator client if --force is not set' do
+      @client.validator(true)
+      @knife.ui.should_receive(:fatal)
+      lambda { @knife.run}.should raise_error(SystemExit)
+    end
+
+    it 'should delete validator client if --force is set' do
+      @knife.config[:force] = true
+      @client.should_receive(:destroy).and_return(@client)
+      @knife.should_receive(:msg)
+
+      @knife.run
+    end
+  end
 end

data/spec/unit/knife_spec.rb

@@ -22,6 +22,7 @@ module KnifeSpecs
 end
 
 require 'spec_helper'
+require 'uri'
 
 describe Chef::Knife do
   before(:each) do
@@ -141,6 +142,60 @@ describe Chef::Knife do
 
   end
 
+  describe "the headers include X-Remote-Request-Id" do
+
+    let(:headers) {{"Accept"=>"application/json",
+                    "Accept-Encoding"=>"gzip;q=1.0,deflate;q=0.6,identity;q=0.3",
+                    'X-Chef-Version' => Chef::VERSION,
+                    "Host"=>"api.opscode.piab:443",
+                    "X-REMOTE-REQUEST-ID"=>request_id}}
+
+    let(:request_id) {"1234"}
+
+    let(:request_mock) { {} }
+
+    let(:rest) do
+      Net::HTTP.stub(:new).and_return(http_client)
+      Chef::RequestID.instance.stub(:request_id).and_return(request_id)
+      Chef::Config.stub(:chef_server_url).and_return("https://api.opscode.piab")
+      command = Chef::Knife.run(%w{test yourself})
+      rest = command.noauth_rest
+      rest
+    end
+
+    let!(:http_client) do
+      http_client = Net::HTTP.new(url.host, url.port)
+      http_client.stub(:request).and_yield(http_response).and_return(http_response)
+      http_client
+    end
+
+    let(:url) { URI.parse("https://api.opscode.piab") }
+
+    let(:http_response) do
+      http_response = Net::HTTPSuccess.new("1.1", "200", "successful rest req")
+      http_response.stub(:read_body)
+      http_response.stub(:body).and_return(body)
+      http_response["Content-Length"] = body.bytesize.to_s
+      http_response
+    end
+
+    let(:body) { "ninja" }
+
+    before(:each) do
+      Chef::Config[:chef_server_url] = "https://api.opscode.piab"
+      if KnifeSpecs.const_defined?(:TestYourself)
+        KnifeSpecs.send :remove_const, :TestYourself
+      end
+      Kernel.load(File.join(CHEF_SPEC_DATA, 'knife_subcommand', 'test_yourself.rb'))
+      Chef::Knife.subcommands.each { |name, klass| Chef::Knife.subcommands.delete(name) unless klass.kind_of?(Class) }
+    end
+
+    it "confirms that the headers include X-Remote-Request-Id" do
+      Net::HTTP::Get.should_receive(:new).with("/monkey", headers).and_return(request_mock)
+      rest.get_rest("monkey")
+    end
+  end
+
   describe "when running a command" do
     before(:each) do
       if KnifeSpecs.const_defined?(:TestYourself)

data/spec/unit/node/attribute_spec.rb

@@ -488,6 +488,13 @@ describe Chef::Node::Attribute do
     end
   end
 
+  describe "dup" do
+    it "array can be duped even if some elements can't" do
+      @attributes.default[:foo] = %w[foo bar baz] + Array(1..3) + [nil, true, false, [ "el", 0, nil ] ]
+      @attributes.default[:foo].dup
+    end
+  end
+
   describe "has_key?" do
     it "should return true if an attribute exists" do
       @attributes.has_key?("music").should == true

data/spec/unit/node/immutable_collections_spec.rb

@@ -86,7 +86,7 @@ end
 describe Chef::Node::ImmutableArray do
 
   before do
-    @immutable_array = Chef::Node::ImmutableArray.new(%w[foo bar baz])
+    @immutable_array = Chef::Node::ImmutableArray.new(%w[foo bar baz] + Array(1..3) + [nil, true, false, [ "el", 0, nil ] ])
   end
 
   ##
@@ -130,6 +130,10 @@ describe Chef::Node::ImmutableArray do
     end
   end
 
+  it "can be duped even if some elements can't" do
+    @immutable_array.dup
+  end
+
   it "returns a mutable version of itself when duped" do
     mutable = @immutable_array.dup
     mutable[0] = :value

data/spec/unit/provider/group_spec.rb

@@ -96,6 +96,11 @@ describe Chef::Provider::User do
       @provider.compare_group.should be_false
     end
 
+    it "should coerce an integer to a string for comparison" do
+      @current_resource.stub!(:gid).and_return("500")
+      @provider.compare_group.should be_false
+    end
+
     it "should return false if append is true and the group member(s) already exists" do
       @current_resource.members << "extra_user"
       @new_resource.stub(:append).and_return(true)

data/spec/unit/provider/ifconfig/debian_spec.rb

@@ -53,38 +53,264 @@ describe Chef::Provider::Ifconfig::Debian do
 
   let(:config_filename_ifcfg) { "/etc/network/interfaces.d/ifcfg-#{new_resource.device}" }
 
-  describe "generate_config for action_add" do
+  describe "generate_config" do
 
-    let(:config_file_ifaces) { StringIO.new }
+    context "when writing a file" do
+      let(:config_file_ifcfg) { StringIO.new }
 
-    let(:config_file_ifcfg) { StringIO.new }
+      let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
 
-    before do
-      expect(FileUtils).to receive(:cp)
-      expect(File).to receive(:open).with(config_filename_ifaces).and_return(StringIO.new)
-      expect(File).to receive(:open).with(config_filename_ifaces, "w").and_yield(config_file_ifaces)
-      expect(File).to receive(:new).with(config_filename_ifcfg, "w").and_return(config_file_ifcfg)
-      expect(File).to receive(:exist?).with(config_filename_ifaces).and_return(true)
-    end
+      let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
+
+      let(:config_filename_ifcfg) { "#{tempdir_path}/ifcfg-#{new_resource.device}" }
+
+      before do
+        stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
+        stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
+        expect(File).to receive(:new).with(config_filename_ifcfg, "w").and_return(config_file_ifcfg)
+      end
+
+      it "should write a network-script" do
+        provider.run_action(:add)
+        expect(config_file_ifcfg.string).to match(/^iface eth0 inet static\s*$/)
+        expect(config_file_ifcfg.string).to match(/^\s+address 10\.0\.0\.1\s*$/)
+        expect(config_file_ifcfg.string).to match(/^\s+netmask 255\.255\.254\.0\s*$/)
+      end
+
+      context "when the interface_dot_d directory does not exist" do
+        before do
+          FileUtils.rmdir tempdir_path
+          expect(File.exists?(tempdir_path)).to be_false
+        end
+
+        it "should create the /etc/network/interfaces.d directory" do
+          provider.run_action(:add)
+          expect(File.exists?(tempdir_path)).to be_true
+          expect(File.directory?(tempdir_path)).to be_true
+        end
 
-    it "should create network-scripts directory" do
-      expect(File).to receive(:directory?).with(File.dirname(config_filename_ifcfg)).and_return(false)
-      expect(Dir).to receive(:mkdir).with(File.dirname(config_filename_ifcfg))
-      provider.run_action(:add)
+        it "should mark the resource as updated" do
+          provider.run_action(:add)
+          expect(new_resource.updated_by_last_action?).to be_true
+        end
+      end
+
+      context "when the interface_dot_d directory exists" do
+        before do
+          expect(File.exists?(tempdir_path)).to be_true
+        end
+
+        it "should still mark the resource as updated (we still write a file to it)" do
+          provider.run_action(:add)
+          expect(new_resource.updated_by_last_action?).to be_true
+        end
+      end
     end
 
-    it "should write configure network-scripts directory" do
-      expect(File).to receive(:directory?).with(File.dirname(config_filename_ifcfg)).and_return(true)
-      provider.run_action(:add)
-      expect(config_file_ifaces.string).to match(/^\s*source\s+\/etc\/network\/interfaces[.]d\/[*]\s*$/)
+    context "when the file is up-to-date" do
+      let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
+
+      let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
+
+      let(:config_filename_ifcfg) { "#{tempdir_path}/ifcfg-#{new_resource.device}" }
+
+      before do
+        stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
+        stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
+        config_file_ifcfg = StringIO.new(<<-EOF
+iface eth0 inet static
+  address 10.0.0.1
+  netmask 255.255.254.0
+EOF
+        )
+        expect(File).to receive(:new).with(config_filename_ifcfg, "w").and_return(config_file_ifcfg)
+        expect(File.exists?(tempdir_path)).to be_true  # since the file exists, the enclosing dir must also exist
+      end
+
+      context "when the /etc/network/interfaces file has the source line" do
+        let(:expected_string) do
+          <<-EOF
+a line
+source #{tempdir_path}/*
+another line
+EOF
+        end
+
+        before do
+          tempfile.write(expected_string)
+          tempfile.close
+        end
+
+        it "should preserve all the contents" do
+          provider.run_action(:add)
+          expect(IO.read(tempfile.path)).to eq(expected_string)
+        end
+
+        it "should not mark the resource as updated" do
+          provider.run_action(:add)
+          pending "superclass ifconfig provider is not idempotent"
+          expect(new_resource.updated_by_last_action?).to be_false
+        end
+      end
+
+      context "when the /etc/network/interfaces file does not have the source line" do
+        let(:expected_string) do
+          <<-EOF
+a line
+another line
+source #{tempdir_path}/*
+EOF
+        end
+
+        before do
+          tempfile.write("a line\nanother line\n")
+          tempfile.close
+        end
+
+        it "should preserve the original contents and add the source line" do
+          provider.run_action(:add)
+          expect(IO.read(tempfile.path)).to eq(expected_string)
+        end
+
+        it "should mark the resource as updated" do
+          provider.run_action(:add)
+          expect(new_resource.updated_by_last_action?).to be_true
+        end
+      end
     end
 
-    it "should write a network-script" do
-      expect(File).to receive(:directory?).with(File.dirname(config_filename_ifcfg)).and_return(true)
-      provider.run_action(:add)
-      expect(config_file_ifcfg.string).to match(/^iface eth0 inet static\s*$/)
-      expect(config_file_ifcfg.string).to match(/^\s+address 10\.0\.0\.1\s*$/)
-      expect(config_file_ifcfg.string).to match(/^\s+netmask 255\.255\.254\.0\s*$/)
+    describe "when running under why run" do
+
+      before do
+        Chef::Config[:why_run] = true
+      end
+
+      after do
+        Chef::Config[:why_run] = false
+      end
+
+      context "when writing a file" do
+        let(:config_file_ifcfg) { StringIO.new }
+
+        let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
+
+        let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
+
+        let(:config_filename_ifcfg) { "#{tempdir_path}/ifcfg-#{new_resource.device}" }
+
+        before do
+          stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
+          stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
+          expect(File).not_to receive(:new).with(config_filename_ifcfg, "w")
+        end
+
+        it "should write a network-script" do
+          provider.run_action(:add)
+          expect(config_file_ifcfg.string).not_to match(/^iface eth0 inet static\s*$/)
+          expect(config_file_ifcfg.string).not_to match(/^\s+address 10\.0\.0\.1\s*$/)
+          expect(config_file_ifcfg.string).not_to match(/^\s+netmask 255\.255\.254\.0\s*$/)
+        end
+
+        context "when the interface_dot_d directory does not exist" do
+          before do
+            FileUtils.rmdir tempdir_path
+            expect(File.exists?(tempdir_path)).to be_false
+          end
+
+          it "should not create the /etc/network/interfaces.d directory" do
+            provider.run_action(:add)
+            expect(File.exists?(tempdir_path)).not_to be_true
+          end
+
+          it "should mark the resource as updated" do
+            provider.run_action(:add)
+            expect(new_resource.updated_by_last_action?).to be_true
+          end
+        end
+
+        context "when the interface_dot_d directory exists" do
+          before do
+            expect(File.exists?(tempdir_path)).to be_true
+          end
+
+          it "should still mark the resource as updated (we still write a file to it)" do
+            provider.run_action(:add)
+            expect(new_resource.updated_by_last_action?).to be_true
+          end
+        end
+      end
+
+      context "when the file is up-to-date" do
+        let(:tempfile) { Tempfile.new("rspec-chef-ifconfig-debian") }
+
+        let(:tempdir_path) { Dir.mktmpdir("rspec-chef-ifconfig-debian-dir") }
+
+        let(:config_filename_ifcfg) { "#{tempdir_path}/ifcfg-#{new_resource.device}" }
+
+        before do
+          stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_FILE", tempfile.path)
+          stub_const("Chef::Provider::Ifconfig::Debian::INTERFACES_DOT_D_DIR", tempdir_path)
+          config_file_ifcfg = StringIO.new(<<-EOF
+iface eth0 inet static
+  address 10.0.0.1
+  netmask 255.255.254.0
+                                           EOF
+                                          )
+          expect(File).not_to receive(:new).with(config_filename_ifcfg, "w")
+          expect(File.exists?(tempdir_path)).to be_true  # since the file exists, the enclosing dir must also exist
+        end
+
+        context "when the /etc/network/interfaces file has the source line" do
+          let(:expected_string) do
+            <<-EOF
+a line
+source #{tempdir_path}/*
+another line
+            EOF
+          end
+
+          before do
+            tempfile.write(expected_string)
+            tempfile.close
+          end
+
+          it "should preserve all the contents" do
+            provider.run_action(:add)
+            expect(IO.read(tempfile.path)).to eq(expected_string)
+          end
+
+          it "should not mark the resource as updated" do
+            provider.run_action(:add)
+            pending "superclass ifconfig provider is not idempotent"
+            expect(new_resource.updated_by_last_action?).to be_false
+          end
+        end
+
+        context "when the /etc/network/interfaces file does not have the source line" do
+          let(:expected_string) do
+            <<-EOF
+a line
+another line
+source #{tempdir_path}/*
+            EOF
+          end
+
+          before do
+            tempfile.write("a line\nanother line\n")
+            tempfile.close
+          end
+
+          it "should preserve the original contents and not add the source line" do
+            provider.run_action(:add)
+            expect(IO.read(tempfile.path)).to eq("a line\nanother line\n")
+          end
+
+          it "should mark the resource as updated" do
+            provider.run_action(:add)
+            expect(new_resource.updated_by_last_action?).to be_true
+          end
+        end
+      end
     end
   end
 
@@ -98,4 +324,5 @@ describe Chef::Provider::Ifconfig::Debian do
       provider.run_action(:delete)
     end
   end
+
 end