chef 12.10.24-universal-mingw32 → 12.11.18-universal-mingw32

data/spec/unit/decorator/lazy_array_spec.rb

@@ -0,0 +1,58 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright 2015-2016, 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::Decorator::LazyArray do
+  def foo
+    @foo ||= 1
+  end
+
+  def bar
+    @bar ||= 2
+  end
+
+  let(:decorator) do
+    Chef::Decorator::LazyArray.new { [ foo, bar ] }
+  end
+
+  it "behaves like an array" do
+    expect(decorator[0]).to eql(1)
+    expect(decorator[1]).to eql(2)
+  end
+
+  it "accessing the array elements is lazy" do
+    expect(decorator[0].class).to eql(Chef::Decorator::Lazy)
+    expect(decorator[1].class).to eql(Chef::Decorator::Lazy)
+    expect(@foo).to be nil
+    expect(@bar).to be nil
+  end
+
+  it "calling a method on the array element runs the proc (and both elements are autovivified)" do
+    expect(decorator[0].nil?).to be false
+    expect(@foo).to equal(1)
+    expect(@bar).to equal(2)
+  end
+
+  it "if we loop over the elements and do nothing then its not lazy" do
+    # we don't know how many elements there are unless we evaluate the proc
+    decorator.each { |i| }
+    expect(@foo).to equal(1)
+    expect(@bar).to equal(2)
+  end
+end

data/spec/unit/decorator/lazy_spec.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright 2015-2016, 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::Decorator::Lazy do
+  let(:decorator) do
+    @a = 0
+    Chef::Decorator::Lazy.new { @a = @a + 1 }
+  end
+
+  it "decorates an object" do
+    expect(decorator.even?).to be false
+  end
+
+  it "the proc runs and does work" do
+    expect(decorator).to eql(1)
+  end
+
+  it "creating the decorator does not cause the proc to run" do
+    decorator
+    expect(@a).to eql(0)
+  end
+end

data/spec/unit/decorator_spec.rb

@@ -0,0 +1,142 @@
+#
+# Author:: Lamont Granquist (<lamont@chef.io>)
+# Copyright:: Copyright 2015-2016, 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"
+
+def impersonates_a(klass)
+  it "#is_a?(#{klass}) is true" do
+    expect(decorator.is_a?(klass)).to be true
+  end
+
+  it "#is_a?(Chef::Decorator) is true" do
+    expect(decorator.is_a?(Chef::Decorator)).to be true
+  end
+
+  it "#kind_of?(#{klass}) is true" do
+    expect(decorator.kind_of?(klass)).to be true
+  end
+
+  it "#kind_of?(Chef::Decorator) is true" do
+    expect(decorator.kind_of?(Chef::Decorator)).to be true
+  end
+
+  it "#instance_of?(#{klass}) is false" do
+    expect(decorator.instance_of?(klass)).to be false
+  end
+
+  it "#instance_of?(Chef::Decorator) is true" do
+    expect(decorator.instance_of?(Chef::Decorator)).to be true
+  end
+
+  it "#class is Chef::Decorator" do
+    expect(decorator.class).to eql(Chef::Decorator)
+  end
+end
+
+describe Chef::Decorator do
+  let(:obj) {}
+  let(:decorator) { Chef::Decorator.new(obj) }
+
+  context "when the obj is a string" do
+    let(:obj) { "STRING" }
+
+    impersonates_a(String)
+
+    it "#nil? is false" do
+      expect(decorator.nil?).to be false
+    end
+
+    it "!! is true" do
+      expect(!!decorator).to be true
+    end
+
+    it "dup returns a decorator" do
+      expect(decorator.dup.class).to be Chef::Decorator
+    end
+
+    it "dup dup's the underlying thing" do
+      expect(decorator.dup.__getobj__).not_to equal(decorator.__getobj__)
+    end
+  end
+
+  context "when the obj is a nil" do
+    let(:obj) { nil }
+
+    it "#nil? is true" do
+      expect(decorator.nil?).to be true
+    end
+
+    it "!! is false" do
+      expect(!!decorator).to be false
+    end
+
+    impersonates_a(NilClass)
+  end
+
+  context "when the obj is an empty Hash" do
+    let(:obj) { {} }
+
+    impersonates_a(Hash)
+
+    it "formats it correctly through ffi-yajl and not the JSON gem" do
+      # this relies on a quirk of pretty formatting whitespace between yajl and ruby's JSON
+      expect(FFI_Yajl::Encoder.encode(decorator, pretty: true)).to eql("{\n\n}\n")
+    end
+  end
+
+  context "whent he obj is a Hash with elements" do
+    let(:obj) { { foo: "bar", baz: "qux" } }
+
+    impersonates_a(Hash)
+
+    it "dup is shallow on the Hash" do
+      expect(decorator.dup[:baz]).to equal(decorator[:baz])
+    end
+
+    it "deep mutating the dup'd hash mutates the origin" do
+      decorator.dup[:baz] << "qux"
+      expect(decorator[:baz]).to eql("quxqux")
+    end
+  end
+
+  context "memoizing methods" do
+    let(:obj) { {} }
+
+    it "calls method_missing only once" do
+      expect(decorator).to receive(:method_missing).once.and_call_original
+      expect(decorator.keys).to eql([])
+      expect(decorator.keys).to eql([])
+    end
+
+    it "switching a Hash to an Array responds to keys then does not" do
+      expect(decorator.respond_to?(:keys)).to be true
+      expect(decorator.keys).to eql([])
+      decorator.__setobj__([])
+      expect(decorator.respond_to?(:keys)).to be false
+      expect { decorator.keys }.to raise_error(NoMethodError)
+    end
+
+    it "memoization of methods happens on the instances, not the classes" do
+      decorator2 = Chef::Decorator.new([])
+      expect(decorator.respond_to?(:keys)).to be true
+      expect(decorator.keys).to eql([])
+      expect(decorator2.respond_to?(:keys)).to be false
+      expect { decorator2.keys }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/unit/environment_spec.rb

@@ -288,11 +288,11 @@ describe Chef::Environment do
 
     describe "in solo mode" do
       before do
-        Chef::Config[:solo] = true
+        Chef::Config[:solo_legacy_mode] = true
       end
 
       after do
-        Chef::Config[:solo] = false
+        Chef::Config[:solo_legacy_mode] = false
       end
 
       it "should raise and exception" do
@@ -392,12 +392,12 @@ describe Chef::Environment do
   describe "when loading" do
     describe "in solo mode" do
       before do
-        Chef::Config[:solo] = true
+        Chef::Config[:solo_legacy_mode] = true
         Chef::Config[:environment_path] = "/var/chef/environments"
       end
 
       after do
-        Chef::Config[:solo] = false
+        Chef::Config[:solo_legacy_mode] = false
       end
 
       it "should get the environment from the environment_path" do

data/spec/unit/handler_spec.rb

@@ -212,4 +212,91 @@ describe Chef::Handler do
     end
   end
 
+  describe "library report handler" do
+    before do
+      # we need to lazily declare this after we have reset Chef::Config in the default rspec before handler
+      class MyTestHandler < Chef::Handler
+        handler_for :report, :exception, :start
+
+        class << self
+          attr_accessor :ran_report
+        end
+
+        def report
+          self.class.ran_report = true
+        end
+      end
+    end
+
+    it "gets added to Chef::Config[:report_handlers]" do
+      expect(Chef::Config[:report_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "gets added to Chef::Config[:exception_handlers]" do
+      expect(Chef::Config[:exception_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "gets added to Chef::Config[:start_handlers]" do
+      expect(Chef::Config[:start_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "runs the report handler" do
+      Chef::Handler.run_report_handlers(@run_status)
+      expect(MyTestHandler.ran_report).to be true
+    end
+
+    it "runs the exception handler" do
+      Chef::Handler.run_exception_handlers(@run_status)
+      expect(MyTestHandler.ran_report).to be true
+    end
+
+    it "runs the start handler" do
+      Chef::Handler.run_start_handlers(@run_status)
+      expect(MyTestHandler.ran_report).to be true
+    end
+  end
+
+  describe "library singleton report handler" do
+    before do
+      # we need to lazily declare this after we have reset Chef::Config in the default rspec before handler
+      class MyTestHandler < Chef::Handler
+        handler_for :report, :exception, :start
+
+        include Singleton
+
+        attr_accessor :ran_report
+
+        def report
+          self.ran_report = true
+        end
+      end
+    end
+
+    it "gets added to Chef::Config[:report_handlers]" do
+      expect(Chef::Config[:report_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "gets added to Chef::Config[:exception_handlers]" do
+      expect(Chef::Config[:exception_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "gets added to Chef::Config[:start_handlers]" do
+      expect(Chef::Config[:start_handlers].include?(MyTestHandler)).to be true
+    end
+
+    it "runs the report handler" do
+      Chef::Handler.run_report_handlers(@run_status)
+      expect(MyTestHandler.instance.ran_report).to be true
+    end
+
+    it "runs the exception handler" do
+      Chef::Handler.run_exception_handlers(@run_status)
+      expect(MyTestHandler.instance.ran_report).to be true
+    end
+
+    it "runs the start handler" do
+      Chef::Handler.run_start_handlers(@run_status)
+      expect(MyTestHandler.instance.ran_report).to be true
+    end
+  end
 end

data/spec/unit/knife/cookbook_show_spec.rb

@@ -20,30 +20,57 @@
 require "spec_helper"
 
 describe Chef::Knife::CookbookShow do
-  before(:each) do
+  before do
     Chef::Config[:node_name] = "webmonkey.example.com"
-    @knife = Chef::Knife::CookbookShow.new
-    @knife.config = {}
-    @knife.name_args = [ "cookbook_name" ]
-    @rest = double(Chef::ServerAPI)
-    allow(@knife).to receive(:rest).and_return(@rest)
-    allow(@knife).to receive(:pretty_print).and_return(true)
-    allow(@knife).to receive(:output).and_return(true)
+    allow(knife).to receive(:rest).and_return(rest)
+    allow(knife).to receive(:pretty_print).and_return(true)
+    allow(knife).to receive(:output).and_return(true)
+    allow(Chef::CookbookVersion).to receive(:load).and_return(cb)
+  end
+
+  let (:knife) do
+    knife = Chef::Knife::CookbookShow.new
+    knife.config = {}
+    knife.name_args = [ "cookbook_name" ]
+    knife
+  end
+
+  let (:cb) do
+    cb = Chef::CookbookVersion.new("cookbook_name")
+    cb.manifest = manifest
+    cb
+  end
+
+  let (:rest) { double(Chef::ServerAPI) }
+
+  let (:content) { "Example recipe text" }
+
+  let (:manifest) do
+    {
+      "recipes" => [
+        {
+          :name => "default.rb",
+          :path => "recipes/default.rb",
+          :checksum => "1234",
+          :url => "http://example.org/files/default.rb",
+        },
+      ],
+    }
   end
 
   describe "run" do
     describe "with 0 arguments: help" do
       it "should should print usage and exit when given no arguments" do
-        @knife.name_args = []
-        expect(@knife).to receive(:show_usage)
-        expect(@knife.ui).to receive(:fatal)
-        expect { @knife.run }.to raise_error(SystemExit)
+        knife.name_args = []
+        expect(knife).to receive(:show_usage)
+        expect(knife.ui).to receive(:fatal)
+        expect { knife.run }.to raise_error(SystemExit)
       end
     end
 
     describe "with 1 argument: versions" do
-      before(:each) do
-        @response = {
+      let (:response) do
+        {
           "cookbook_name" => {
             "url" => "http://url/cookbooks/cookbook_name",
             "versions" => [
@@ -56,87 +83,60 @@ describe Chef::Knife::CookbookShow do
       end
 
       it "should show the raw cookbook data" do
-        expect(@rest).to receive(:get).with("cookbooks/cookbook_name").and_return(@response)
-        expect(@knife).to receive(:format_cookbook_list_for_display).with(@response)
-        @knife.run
+        expect(rest).to receive(:get).with("cookbooks/cookbook_name").and_return(response)
+        expect(knife).to receive(:format_cookbook_list_for_display).with(response)
+        knife.run
       end
 
       it "should respect the user-supplied environment" do
-        @knife.config[:environment] = "foo"
-        expect(@rest).to receive(:get).with("environments/foo/cookbooks/cookbook_name").and_return(@response)
-        expect(@knife).to receive(:format_cookbook_list_for_display).with(@response)
-        @knife.run
+        knife.config[:environment] = "foo"
+        expect(rest).to receive(:get).with("environments/foo/cookbooks/cookbook_name").and_return(response)
+        expect(knife).to receive(:format_cookbook_list_for_display).with(response)
+        knife.run
       end
     end
 
     describe "with 2 arguments: name and version" do
-      before(:each) do
-        @knife.name_args << "0.1.0"
-        @response = { "0.1.0" => { "recipes" => { "default.rb" => "" } } }
+      before do
+        knife.name_args << "0.1.0"
       end
 
       it "should show the specific part of a cookbook" do
-        expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@response)
-        expect(@knife).to receive(:output).with(@response)
-        @knife.run
+        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+        expect(knife).to receive(:output).with(cb)
+        knife.run
       end
     end
 
     describe "with 3 arguments: name, version, and segment" do
       before(:each) do
-        @knife.name_args = [ "cookbook_name", "0.1.0", "recipes" ]
-        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
-        @manifest = {
-          "recipes" => [
-            {
-              :name => "default.rb",
-              :path => "recipes/default.rb",
-              :checksum => "1234",
-              :url => "http://example.org/files/default.rb",
-            },
-          ],
-        }
-        @cookbook_response.manifest = @manifest
-        @response = { "name" => "default.rb", "url" => "http://example.org/files/default.rb", "checksum" => "1234", "path" => "recipes/default.rb" }
+        knife.name_args = [ "cookbook_name", "0.1.0", "recipes" ]
       end
 
       it "should print the json of the part" do
-        expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-        expect(@knife).to receive(:output).with(@cookbook_response.manifest["recipes"])
-        @knife.run
+        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+        expect(knife).to receive(:output).with(cb.manifest["recipes"])
+        knife.run
       end
     end
 
     describe "with 4 arguments: name, version, segment and filename" do
       before(:each) do
-        @knife.name_args = [ "cookbook_name", "0.1.0", "recipes", "default.rb" ]
-        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
-        @cookbook_response.manifest = {
-          "recipes" => [
-            {
-              :name => "default.rb",
-              :path => "recipes/default.rb",
-              :checksum => "1234",
-              :url => "http://example.org/files/default.rb",
-            },
-          ],
-        }
-        @response = "Example recipe text"
+        knife.name_args = [ "cookbook_name", "0.1.0", "recipes", "default.rb" ]
       end
 
       it "should print the raw result of the request (likely a file!)" do
-        expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-        expect(@rest).to receive(:streaming_request).with("http://example.org/files/default.rb").and_return(StringIO.new(@response))
-        expect(@knife).to receive(:pretty_print).with(@response)
-        @knife.run
+        expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+        expect(rest).to receive(:streaming_request).with("http://example.org/files/default.rb").and_return(StringIO.new(content))
+        expect(knife).to receive(:pretty_print).with(content)
+        knife.run
       end
     end
 
     describe "with 4 arguments: name, version, segment and filename -- with specificity" do
       before(:each) do
-        @knife.name_args = [ "cookbook_name", "0.1.0", "files", "afile.rb" ]
-        @cookbook_response = Chef::CookbookVersion.new("cookbook_name")
-        @cookbook_response.manifest = {
+        knife.name_args = [ "cookbook_name", "0.1.0", "files", "afile.rb" ]
+        cb.manifest = {
           "files" => [
             {
               :name => "afile.rb",
@@ -169,51 +169,50 @@ describe Chef::Knife::CookbookShow do
           ],
         }
 
-        @response = "Example recipe text"
       end
 
       describe "with --fqdn" do
         it "should pass the fqdn" do
-          @knife.config[:platform] = "example_platform"
-          @knife.config[:platform_version] = "1.0"
-          @knife.config[:fqdn] = "examplehost.example.org"
-          expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-          expect(@rest).to receive(:streaming_request).with("http://example.org/files/1111").and_return(StringIO.new(@response))
-          expect(@knife).to receive(:pretty_print).with(@response)
-          @knife.run
+          knife.config[:platform] = "example_platform"
+          knife.config[:platform_version] = "1.0"
+          knife.config[:fqdn] = "examplehost.example.org"
+          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+          expect(rest).to receive(:streaming_request).with("http://example.org/files/1111").and_return(StringIO.new(content))
+          expect(knife).to receive(:pretty_print).with(content)
+          knife.run
         end
       end
 
       describe "and --platform" do
         it "should pass the platform" do
-          @knife.config[:platform] = "ubuntu"
-          @knife.config[:platform_version] = "1.0"
-          @knife.config[:fqdn] = "differenthost.example.org"
-          expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-          expect(@rest).to receive(:streaming_request).with("http://example.org/files/3333").and_return(StringIO.new(@response))
-          expect(@knife).to receive(:pretty_print).with(@response)
-          @knife.run
+          knife.config[:platform] = "ubuntu"
+          knife.config[:platform_version] = "1.0"
+          knife.config[:fqdn] = "differenthost.example.org"
+          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+          expect(rest).to receive(:streaming_request).with("http://example.org/files/3333").and_return(StringIO.new(content))
+          expect(knife).to receive(:pretty_print).with(content)
+          knife.run
         end
       end
 
       describe "and --platform-version" do
         it "should pass the platform" do
-          @knife.config[:platform] = "ubuntu"
-          @knife.config[:platform_version] = "9.10"
-          @knife.config[:fqdn] = "differenthost.example.org"
-          expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-          expect(@rest).to receive(:streaming_request).with("http://example.org/files/2222").and_return(StringIO.new(@response))
-          expect(@knife).to receive(:pretty_print).with(@response)
-          @knife.run
+          knife.config[:platform] = "ubuntu"
+          knife.config[:platform_version] = "9.10"
+          knife.config[:fqdn] = "differenthost.example.org"
+          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+          expect(rest).to receive(:streaming_request).with("http://example.org/files/2222").and_return(StringIO.new(content))
+          expect(knife).to receive(:pretty_print).with(content)
+          knife.run
         end
       end
 
       describe "with none of the arguments, it should use the default" do
         it "should pass them all" do
-          expect(@rest).to receive(:get).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response)
-          expect(@rest).to receive(:streaming_request).with("http://example.org/files/4444").and_return(StringIO.new(@response))
-          expect(@knife).to receive(:pretty_print).with(@response)
-          @knife.run
+          expect(Chef::CookbookVersion).to receive(:load).with("cookbook_name", "0.1.0").and_return(cb)
+          expect(rest).to receive(:streaming_request).with("http://example.org/files/4444").and_return(StringIO.new(content))
+          expect(knife).to receive(:pretty_print).with(content)
+          knife.run
         end
       end