chef 12.18.31 → 13.0.118

data/spec/functional/resource/link_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: John Keiser (<jkeiser@chef.io>)
-# Copyright:: Copyright 2011-2016, Chef Software Inc.
+# Copyright:: Copyright 2011-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -654,7 +654,7 @@ describe Chef::Resource::Link do
           end
           context "and the link does not yet exist" do
             it "links to the target file" do
-              skip("OS X/FreeBSD/AIX symlink? and readlink working on hard links to symlinks") if os_x? || freebsd? || aix?
+              skip("OS X/FreeBSD/AIX/Solaris symlink? and readlink working on hard links to symlinks") if os_x? || freebsd? || aix? || solaris?
               resource.run_action(:create)
               expect(File.exists?(target_file)).to be_truthy
               # OS X gets angry about this sort of link.  Bug in OS X, IMO.
@@ -673,7 +673,7 @@ describe Chef::Resource::Link do
           end
           context "and the link does not yet exist" do
             it "links to the target file" do
-              skip("OS X/FreeBSD/AIX fails to create hardlinks to broken symlinks") if os_x? || freebsd? || aix?
+              skip("OS X/FreeBSD/AIX/Solaris fails to create hardlinks to broken symlinks") if os_x? || freebsd? || aix? || solaris?
               resource.run_action(:create)
               expect(File.exists?(target_file) || File.symlink?(target_file)).to be_truthy
               expect(symlink?(target_file)).to be_truthy

data/spec/functional/resource/template_spec.rb

@@ -32,6 +32,7 @@ describe Chef::Resource::Template do
   let(:node) do
     node = Chef::Node.new
     node.normal[:slappiness] = "a warm gun"
+    node.normal[:nested][:secret] = "value"
     node
   end
 
@@ -209,4 +210,36 @@ describe Chef::Resource::Template do
     end
   end
 
+  describe "when template variables contain lazy{} calls" do
+    it "resolves the DelayedEvaluator" do
+      resource.source("openldap_variable_stuff.conf.erb")
+      resource.variables(:secret => Chef::DelayedEvaluator.new { "nutella" })
+      resource.run_action(:create)
+      expect(IO.read(path)).to eq("super secret is nutella")
+    end
+
+    it "does not mutate the resource variables" do
+      resource.source("openldap_variable_stuff.conf.erb")
+      resource.variables(:secret => Chef::DelayedEvaluator.new { "nutella" })
+      resource.run_action(:create)
+      expect(resource.variables[:secret]).to be_a Chef::DelayedEvaluator
+    end
+
+    it "resolves the DelayedEvaluator when deeply nested" do
+      resource.source("openldap_nested_variable_stuff.erb")
+      resource.variables(:secret => [{ "key" => Chef::DelayedEvaluator.new { "nutella" } }])
+      resource.run_action(:create)
+      expect(IO.read(path)).to eq("super secret is nutella")
+    end
+  end
+
+  describe "when passing a node attribute mash as a template variable" do
+    it "uses the node attributes like a hash" do
+      resource.source("openldap_variable_stuff.conf.erb")
+      resource.variables(node[:nested])
+      resource.run_action(:create)
+      expect(IO.read(path)).to eq("super secret is value")
+    end
+  end
+
 end

data/spec/functional/resource/user/dscl_spec.rb

@@ -28,11 +28,9 @@ describe "Chef::Resource::User with Chef::Provider::User::Dscl provider", metada
   include Chef::Mixin::ShellOut
 
   def clean_user
-    begin
-      shell_out!("/usr/bin/dscl . -delete '/Users/#{username}'")
-    rescue Mixlib::ShellOut::ShellCommandFailed
+    shell_out!("/usr/bin/dscl . -delete '/Users/#{username}'")
+  rescue Mixlib::ShellOut::ShellCommandFailed
       # Raised when the user is already cleaned
-    end
   end
 
   def user_should_exist

data/spec/functional/root_alias_spec.rb

@@ -0,0 +1,78 @@
+#
+# Copyright:: Copyright 2017, Noah Kantrowitz
+# 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 "root aliases" do
+  let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "root_alias_cookbooks")) }
+  let(:cookbook_collection) do
+    cl = Chef::CookbookLoader.new(chef_repo_path)
+    cl.load_cookbooks
+    Chef::CookbookCollection.new(cl)
+  end
+  let(:node) do
+    node = Chef::Node.new
+    node.automatic[:recipes] = []
+    node
+  end
+  let(:events) { Chef::EventDispatch::Dispatcher.new }
+  let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
+  before do
+    node.run_context = run_context
+  end
+
+  describe "attributes root aliases" do
+    it "should load attributes.rb when included directly" do
+      node.include_attribute("simple")
+      expect(node["aliased"]["attr"]).to eq "value"
+    end
+
+    it "should load attributes.rb when loading a cookbook" do
+      node.run_list << "simple"
+      run_context.load(node.run_list.expand("_default"))
+      expect(node["aliased"]["attr"]).to eq "value"
+    end
+
+    context "with both an attributes.rb and attributes/default.rb" do
+      it "should log an error and ignore attributes/default.rb" do
+        expect(Chef::Log).to receive(:error).with("Cookbook dup_attr contains both attributes.rb and and attributes/default.rb, ignoring attributes/default.rb")
+        node.run_list << "dup_attr"
+        run_context.load(node.run_list.expand("_default"))
+        expect(node["aliased"]["attr"]).to eq "value"
+      end
+    end
+  end
+
+  describe "recipe root aliased" do
+    it "should load recipe.rb" do
+      node.run_list << "simple"
+      run_context.load(node.run_list.expand("_default"))
+      run_context.include_recipe("simple")
+      expect(run_context.resource_collection.map(&:to_s)).to eq ["ruby_block[root alias]"]
+    end
+
+    context "with both an recipe.rb and recipes/default.rb" do
+      it "should log an error and ignore recipes/default.rb" do
+        expect(Chef::Log).to receive(:error).with("Cookbook dup_recipe contains both recipe.rb and and recipes/default.rb, ignoring recipes/default.rb")
+        node.run_list << "dup_recipe"
+        run_context.load(node.run_list.expand("_default"))
+        run_context.include_recipe("dup_recipe")
+        expect(run_context.resource_collection.map(&:to_s)).to eq ["ruby_block[root alias]"]
+      end
+    end
+  end
+end

data/spec/functional/shell_spec.rb

@@ -1,6 +1,6 @@
 #
 # Author:: Daniel DeLeo (<dan@chef.io>)
-# Copyright:: Copyright 2012-2016, Chef Software, Inc.
+# Copyright:: Copyright 2012-2017, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -20,7 +20,6 @@ require "spec_helper"
 require "functional/resource/base"
 require "chef/version"
 require "chef/shell"
-require "chef/mixin/command/unix"
 
 describe Shell do
 
@@ -28,7 +27,6 @@ describe Shell do
   # not catch cases where chef-shell fails to boot because of changes in
   # chef/client.rb
   describe "smoke tests", :unix_only => true do
-    include Chef::Mixin::Command::Unix
 
     TIMEOUT = 300
 
@@ -79,44 +77,26 @@ describe Shell do
     end
 
     def run_chef_shell_with(options)
-      case ohai[:platform]
-      when "aix"
-        config = File.expand_path("shef-config.rb", CHEF_SPEC_DATA)
-        path_to_chef_shell = File.expand_path("../../../bin/chef-shell", __FILE__)
-        output = ""
-        status = popen4("#{path_to_chef_shell} -c #{config} #{options}", :waitlast => true) do |pid, stdin, stdout, stderr|
-          read_until(stdout, "chef (#{Chef::VERSION})>")
-          yield stdout, stdin if block_given?
-          stdin.write("'done'\n")
-          output = read_until(stdout, '=> "done"')
-          stdin.print("exit\n")
-          flush_output(stdout)
-        end
+      # Windows ruby installs don't (always?) have PTY,
+      # so hide the require here
 
-        [output, status.exitstatus]
-      else
-        # Windows ruby installs don't (always?) have PTY,
-        # so hide the require here
-        begin
-          require "pty"
-          config = File.expand_path("shef-config.rb", CHEF_SPEC_DATA)
-          path_to_chef_shell = File.expand_path("../../../bin/chef-shell", __FILE__)
-          reader, writer, pid = PTY.spawn("#{path_to_chef_shell} -c #{config} #{options}")
-          read_until(reader, "chef (#{Chef::VERSION})>")
-          yield reader, writer if block_given?
-          writer.puts('"done"')
-          output = read_until(reader, '=> "done"')
-          writer.print("exit\n")
-          flush_output(reader)
-          writer.close
-
-          exitstatus = wait_or_die(pid)
-
-          [output, exitstatus]
-        rescue PTY::ChildExited => e
-          [output, e.status]
-        end
-      end
+      require "pty"
+      config = File.expand_path("shef-config.rb", CHEF_SPEC_DATA)
+      path_to_chef_shell = File.expand_path("../../../bin/chef-shell", __FILE__)
+      reader, writer, pid = PTY.spawn("#{path_to_chef_shell} -c #{config} #{options}")
+      read_until(reader, "chef (#{Chef::VERSION})>")
+      yield reader, writer if block_given?
+      writer.puts('"done"')
+      output = read_until(reader, '=> "done"')
+      writer.print("exit\n")
+      flush_output(reader)
+      writer.close
+
+      exitstatus = wait_or_die(pid)
+
+      [output, exitstatus]
+    rescue PTY::ChildExited => e
+      [output, e.status]
     end
 
     it "boots correctly with -lauto" do
@@ -135,6 +115,24 @@ describe Shell do
       expect(exitstatus).to eq(0)
     end
 
+    context "on solo mode" do
+      it "starts correctly" do
+        output, exitstatus = run_chef_shell_with("--solo")
+        expect(output).to include("done")
+        expect(exitstatus).to eq(0)
+      end
+
+      it "should be able to use the API" do
+        output, exitstatus = run_chef_shell_with("-s") do |out, keyboard|
+          simple_api_get = "api.get('data')"
+          keyboard.puts(simple_api_get)
+          read_until(out, simple_api_get)
+        end
+        expect(output).to include("{}")
+        expect(exitstatus).to eq(0)
+      end
+    end
+
     it "sets the override_runlist from the command line" do
       output, exitstatus = run_chef_shell_with("-o 'override::foo,override::bar'") do |out, keyboard|
         show_recipes_code = %q[puts "#{node["recipes"].inspect}"]

data/spec/integration/client/client_spec.rb

@@ -46,6 +46,7 @@ describe "chef-client" do
   # we're running `chef-client` from the source tree and not the external one.
   # cf. CHEF-4914
   let(:chef_client) { "ruby '#{chef_dir}/chef-client' --minimal-ohai" }
+  let(:chef_solo) { "ruby '#{chef_dir}/chef-solo' --minimal-ohai" }
 
   let(:critical_env_vars) { %w{_ORIGINAL_GEM_PATH GEM_PATH GEM_HOME GEM_ROOT BUNDLE_BIN_PATH BUNDLE_GEMFILE RUBYLIB RUBYOPT RUBY_ENGINE RUBY_ROOT RUBY_VERSION PATH}.map { |o| "#{o}=#{ENV[o]}" } .join(" ") }
 
@@ -293,10 +294,9 @@ chef_server_url 'http://omg.com/blah'
 cookbook_path "#{path_to('cookbooks')}"
 EOM
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -r 'x::default' -z", :cwd => chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -r 'x::default' -z -l info", :cwd => chef_dir)
       expect(result.stdout).not_to include("Overridden Run List")
       expect(result.stdout).to include("Run List is [recipe[x::default]]")
-      #puts result.stdout
       result.error!
     end
 
@@ -387,18 +387,8 @@ EOM
   when_the_repository "has a cookbook that generates deprecation warnings" do
     before do
       file "cookbooks/x/recipes/default.rb", <<-EOM
-        class ::MyResource < Chef::Resource
-          use_automatic_resource_name
-          property :x, default: []
-          property :y, default: {}
-        end
-
-        my_resource 'blah' do
-          1.upto(10) do
-            x nil
-          end
-          x nil
-        end
+        Chef.deprecated(:internal_api, "Test deprecation")
+        Chef.deprecated(:internal_api, "Test deprecation")
       EOM
     end
 
@@ -431,7 +421,7 @@ EOM
       expect(run_complete).to be >= 0
 
       # Make sure there is exactly one result for each, and that it occurs *after* the complete message.
-      expect(match_indices(/An attempt was made to change x from \[\] to nil by calling x\(nil\). In Chef 12, this does a get rather than a set. In Chef 13, this will change to set the value to nil./, result.stdout)).to match([ be > run_complete ])
+      expect(match_indices(/Test deprecation/, result.stdout)).to match([ be > run_complete ])
     end
   end
 
@@ -454,7 +444,7 @@ control_group "control group without top level control" do
 end
       RECIPE
 
-      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::succeed'", :cwd => chef_dir)
+      result = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'audit_test::succeed' -l info", :cwd => chef_dir)
       expect(result.error?).to be_falsey
       expect(result.stdout).to include("Successfully executed all `control_group` blocks and contained examples")
     end
@@ -474,6 +464,39 @@ end
     end
   end
 
+  when_the_repository "has a cookbook with an ohai plugin" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<-RECIPE
+file #{path_to('tempfile.txt').inspect} do
+  content node["english"]["version"]
+end
+      RECIPE
+
+      file "cookbooks/x/ohai/english.rb", <<-OHAI
+        Ohai.plugin(:English) do
+          provides 'english'
+
+          collect_data do
+            english Mash.new
+            english[:version] = "2014"
+          end
+        end
+      OHAI
+
+      file "config/client.rb", <<EOM
+local_mode true
+cookbook_path "#{path_to('cookbooks')}"
+EOM
+    end
+
+    it "should run the ohai plugin" do
+      result = shell_out("#{chef_client} -l debug -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", :cwd => chef_dir)
+      result.error!
+
+      expect(IO.read(path_to("tempfile.txt"))).to eq("2014")
+    end
+  end
+
   # Fails on appveyor, but works locally on windows and on windows hosts in Ci.
   context "when using recipe-url", :skip_appveyor do
     before(:each) do
@@ -499,4 +522,74 @@ EOM
       expect(result.exitstatus).not_to eq(0)
     end
   end
+
+  when_the_repository "has a cookbook with broken metadata.rb, but has metadata.json" do
+    before do
+      file "cookbooks/x/recipes/default.rb", ""
+      file "cookbooks/x/metadata.rb", <<EOM
+name 'x'
+version '0.0.1'
+raise "TEH SADNESS"
+EOM
+      file "cookbooks/x/metadata.json", <<EOM
+{
+  "name": "x",
+  "version": "0.0.1"
+}
+EOM
+
+      file "config/client.rb", <<EOM
+local_mode true
+cookbook_path "#{path_to('cookbooks')}"
+EOM
+    end
+
+    it "the chef client run should succeed" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", :cwd => chef_dir)
+      command.error!
+    end
+
+    it "a chef-solo run should succeed" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", :cwd => chef_dir)
+      command.error!
+    end
+  end
+
+  when_the_repository "has a cookbook that logs at the info level" do
+    before do
+      file "cookbooks/x/recipes/default.rb", <<EOM
+      log "info level" do
+        level :info
+      end
+EOM
+      file "config/client.rb", <<EOM
+local_mode true
+cookbook_path "#{path_to('cookbooks')}"
+EOM
+    end
+
+    it "a chef client run should not log to info by default" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", :cwd => chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef client run to a pipe should not log to info by default" do
+      command = shell_out("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", :cwd => chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef solo run should not log to info by default" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork", :cwd => chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+
+    it "a chef solo run to a pipe should not log to info by default" do
+      command = shell_out("#{chef_solo} -c \"#{path_to('config/client.rb')}\" -o 'x::default' --no-fork | tee #{path_to('chefrun.out')}", :cwd => chef_dir)
+      command.error!
+      expect(command.stdout).not_to include("INFO")
+    end
+  end
 end

data/spec/integration/client/exit_code_spec.rb

@@ -25,7 +25,7 @@ describe "chef-client" do
 
   let(:critical_env_vars) { %w{PATH RUBYOPT BUNDLE_GEMFILE GEM_PATH}.map { |o| "#{o}=#{ENV[o]}" } .join(" ") }
 
-  when_the_repository "does not have exit_status configured" do
+  when_the_repository "uses RFC 062 defined exit codes" do
 
     def setup_client_rb
       file "config/client.rb", <<EOM
@@ -42,110 +42,6 @@ audit_mode :audit_only
 EOM
     end
 
-    def run_chef_client_and_expect_exit_code(exit_code)
-      shell_out!(
-        "#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'",
-        :cwd => chef_dir,
-        :returns => [exit_code])
-    end
-
-    context "has a cookbook" do
-      context "with a library" do
-        context "which cannot be loaded" do
-          before do
-            file "cookbooks/x/recipes/default.rb", ""
-            file "cookbooks/x/libraries/error.rb", "require 'does/not/exist'"
-          end
-
-          it "exits with GENERIC_FAILURE, 1" do
-            setup_client_rb
-            run_chef_client_and_expect_exit_code 1
-          end
-        end
-      end
-
-      context "with an audit recipe" do
-        context "which fails" do
-          before do
-            file "cookbooks/x/recipes/default.rb", <<-RECIPE
-control_group "control group without top level control" do
-  it "should fail" do
-    expect(2 - 2).to eq(1)
-  end
-end
-RECIPE
-          end
-
-          it "exits with GENERIC_FAILURE, 1" do
-            setup_client_rb_with_audit_mode
-            run_chef_client_and_expect_exit_code 1
-          end
-        end
-      end
-
-      context "with a recipe" do
-        context "which throws an error" do
-          before { file "cookbooks/x/recipes/default.rb", "raise 'BOOM'" }
-
-          it "exits with GENERIC_FAILURE, 1" do
-            setup_client_rb
-            run_chef_client_and_expect_exit_code 1
-          end
-        end
-
-        context "with a recipe which calls Chef::Application.fatal with a non-RFC exit code" do
-          before { file "cookbooks/x/recipes/default.rb", "Chef::Application.fatal!('BOOM', 123)" }
-
-          it "exits with the specified exit code" do
-            setup_client_rb
-            run_chef_client_and_expect_exit_code 123
-          end
-        end
-
-        context "with a recipe which calls Chef::Application.exit with a non-RFC exit code" do
-          before { file "cookbooks/x/recipes/default.rb", "Chef::Application.exit!('BOOM', 231)" }
-
-          it "exits with the specified exit code" do
-            setup_client_rb
-            run_chef_client_and_expect_exit_code 231
-          end
-        end
-      end
-
-      context "when an attempt to reboot fails (like from the reboot resource)" do
-        before do
-          file "cookbooks/x/recipes/default.rb", <<EOM
-raise Chef::Exceptions::RebootFailed.new
-EOM
-        end
-
-        it "exits with GENERIC_FAILURE, 1" do
-          setup_client_rb
-          run_chef_client_and_expect_exit_code 1
-        end
-      end
-    end
-  end
-
-  when_the_repository "does has exit_status enabled" do
-
-    def setup_client_rb
-      file "config/client.rb", <<EOM
-local_mode true
-cookbook_path "#{path_to('cookbooks')}"
-exit_status :enabled
-EOM
-    end
-
-    def setup_client_rb_with_audit_mode
-      file "config/client.rb", <<EOM
-local_mode true
-cookbook_path "#{path_to('cookbooks')}"
-exit_status :enabled
-audit_mode :audit_only
-EOM
-    end
-
     def run_chef_client_and_expect_exit_code(exit_code)
       shell_out!("#{chef_client} -c \"#{path_to('config/client.rb')}\" -o 'x::default'",
         :cwd => chef_dir,

data/spec/integration/knife/chef_repository_file_system_spec.rb

@@ -158,103 +158,6 @@ EOM
       end
     end
 
-    when_the_repository "has extraneous subdirectories and files under a cookbook" do
-      before do
-        directory "cookbooks/cookbook1" do
-          file "a.rb", ""
-          file "blarghle/blah.rb", ""
-          directory "attributes" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "definitions" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "recipes" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "libraries" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "templates" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "files" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "resources" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-          directory "providers" do
-            file "a.rb", ""
-            file "b.json", {}
-            file "c/d.rb", ""
-            file "c/e.json", {}
-          end
-        end
-      end
-
-      it "knife list --local -Rfp / should NOT return them" do
-        knife("list --local -Rfp /").should_succeed <<EOM
-/cookbooks/
-/cookbooks/cookbook1/
-/cookbooks/cookbook1/a.rb
-/cookbooks/cookbook1/attributes/
-/cookbooks/cookbook1/attributes/a.rb
-/cookbooks/cookbook1/definitions/
-/cookbooks/cookbook1/definitions/a.rb
-/cookbooks/cookbook1/files/
-/cookbooks/cookbook1/files/a.rb
-/cookbooks/cookbook1/files/b.json
-/cookbooks/cookbook1/files/c/
-/cookbooks/cookbook1/files/c/d.rb
-/cookbooks/cookbook1/files/c/e.json
-/cookbooks/cookbook1/libraries/
-/cookbooks/cookbook1/libraries/a.rb
-/cookbooks/cookbook1/libraries/b.json
-/cookbooks/cookbook1/libraries/c/
-/cookbooks/cookbook1/libraries/c/d.rb
-/cookbooks/cookbook1/libraries/c/e.json
-/cookbooks/cookbook1/providers/
-/cookbooks/cookbook1/providers/a.rb
-/cookbooks/cookbook1/providers/c/
-/cookbooks/cookbook1/providers/c/d.rb
-/cookbooks/cookbook1/recipes/
-/cookbooks/cookbook1/recipes/a.rb
-/cookbooks/cookbook1/resources/
-/cookbooks/cookbook1/resources/a.rb
-/cookbooks/cookbook1/resources/c/
-/cookbooks/cookbook1/resources/c/d.rb
-/cookbooks/cookbook1/templates/
-/cookbooks/cookbook1/templates/a.rb
-/cookbooks/cookbook1/templates/b.json
-/cookbooks/cookbook1/templates/c/
-/cookbooks/cookbook1/templates/c/d.rb
-/cookbooks/cookbook1/templates/c/e.json
-EOM
-      end
-    end
-
     when_the_repository "has a file in cookbooks/" do
       before { file "cookbooks/file", "" }
       it "does not show up in list -Rfp" do