chef 16.3.45 → 16.4.35

data/spec/unit/resource/osx_profile_spec.rb

@@ -58,4 +58,237 @@ describe Chef::Resource::OsxProfile do
     resource.profile test_profile
     expect(resource.profile).to be_a(Hash)
   end
+
+  let(:shell_out_success) do
+    double("shell_out", exitstatus: 0, error?: false)
+  end
+
+  describe "action_create" do
+    let(:node) { Chef::Node.new }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:run_context) { Chef::RunContext.new(node, {}, events) }
+    let(:resource) { Chef::Resource::OsxProfile.new("Profile Test", run_context) }
+    let(:provider) { resource.provider_for_action(:create) }
+    let(:all_profiles) do
+      { "_computerlevel" => [{ "ProfileDisplayName" => "Finder Settings",
+                               "ProfileIdentifier" => "com.apple.finder",
+                               "ProfileInstallDate" => "2015-11-08 23:15:21 +0000",
+                               "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.finder" => { "Forced" => [{ "mcx_preference_settings" => { "ShowExternalHardDrivesOnDesktop" => false } }] } } },
+                                                    "PayloadDisplayName" => "Custom: (com.apple.finder)",
+                                                    "PayloadIdentifier" => "com.apple.finder",
+                                                    "PayloadType" => "com.apple.ManagedClient.preferences",
+                                                    "PayloadUUID" => "a017048f-684b-4e81-baa3-43afe316d739",
+                                                    "PayloadVersion" => 1 }],
+                               "ProfileOrganization" => "Chef",
+                               "ProfileRemovalDisallowed" => "false",
+                               "ProfileType" => "Configuration",
+                               "ProfileUUID" => "e2e09bef-e673-44a6-bcbe-ecb5f1c1b740",
+                               "ProfileVerificationState" => "unsigned",
+                               "ProfileVersion" => 1 },
+        { "ProfileDisplayName" => "ScreenSaver Settings",
+          "ProfileIdentifier" => "com.testprofile.screensaver",
+          "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+          "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                               "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                               "PayloadIdentifier" => "com.apple.screensaver",
+                               "PayloadType" => "com.apple.ManagedClient.preferences",
+                               "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c110",
+                               "PayloadVersion" => 1 }],
+          "ProfileOrganization" => "Chef",
+          "ProfileRemovalDisallowed" => "false",
+          "ProfileType" => "Configuration",
+          "ProfileUUID" => "6e95927c-f200-54b4-85c7-52ab99b61c47",
+          "ProfileVerificationState" => "unsigned",
+          "ProfileVersion" => 1 }],
+      }
+    end
+    # If anything is changed within this profile, be sure to update the
+    # ProfileUUID in all_profiles to match the new config specific UUID
+    let(:test_profile) do
+      {
+        "PayloadIdentifier" => "com.testprofile.screensaver",
+        "PayloadRemovalDisallowed" => false,
+        "PayloadScope" => "System",
+        "PayloadType" => "Configuration",
+        "PayloadUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+        "PayloadOrganization" => "Chef",
+        "PayloadVersion" => 1,
+        "PayloadDisplayName" => "Screensaver Settings",
+        "PayloadContent" => [
+          {
+            "PayloadType" => "com.apple.ManagedClient.preferences",
+            "PayloadVersion" => 1,
+            "PayloadIdentifier" => "com.testprofile.screensaver",
+            "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c108",
+            "PayloadEnabled" => true,
+            "PayloadDisplayName" => "com.apple.screensaver",
+            "PayloadContent" => {
+              "com.apple.screensaver" => {
+                "Forced" => [
+                  {
+                    "mcx_preference_settings" => {
+                      "idleTime" => 0,
+                    },
+                  },
+                ],
+              },
+            },
+          },
+        ],
+        }
+    end
+    let(:no_profiles) do
+      {}
+    end
+
+    before(:each) do
+      allow(provider).to receive(:cookbook_file_available?).and_return(true)
+      allow(provider).to receive(:cache_cookbook_profile).and_return("/tmp/test.mobileconfig.remote")
+      allow(provider).to receive(:get_new_profile_hash).and_return(test_profile)
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+      allow(provider).to receive(:read_plist).and_return(all_profiles)
+      allow(::File).to receive(:unlink).and_return(true)
+    end
+
+    it "should build the get all profiles shellout command correctly" do
+      profile_name = "com.testprofile.screensaver.mobileconfig"
+      resource.profile_name profile_name
+      allow(provider).to receive(:get_installed_profiles).and_call_original
+      allow(provider).to receive(:read_plist).and_return(all_profiles)
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-P", "-o", kind_of(String))
+      provider.load_current_resource
+    end
+
+    it "should use profile name as profile when no profile is set" do
+      profile_name = "com.testprofile.screensaver.mobileconfig"
+      resource.profile_name profile_name
+      provider.load_current_resource
+      expect(resource.profile_name).to eql(profile_name)
+    end
+
+    it "should use identifier from specified profile" do
+      resource.profile test_profile
+      provider.load_current_resource
+      expect(
+        provider.instance_variable_get(:@new_profile_identifier)
+      ).to eql(test_profile["PayloadIdentifier"])
+    end
+
+    it "should install when not installed" do
+      resource.profile test_profile
+      allow(provider).to receive(:get_installed_profiles).and_return(no_profiles)
+      provider.load_current_resource
+      expect(provider).to receive(:install_profile)
+      expect { provider.run_action(:install) }.to_not raise_error
+    end
+
+    it "does not install if the profile is already installed" do
+      resource.profile test_profile
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+      provider.load_current_resource
+      expect(provider).to_not receive(:install_profile)
+      expect { provider.action_install }.to_not raise_error
+    end
+
+    it "should install when installed but uuid differs" do
+      resource.profile test_profile
+      all_profiles["_computerlevel"][1]["ProfileUUID"] = "1781fbec-3325-565f-9022-9bb39245d4dd"
+      provider.load_current_resource
+      expect(provider).to receive(:install_profile)
+      expect { provider.run_action(:install) }.to_not raise_error
+    end
+
+    it "should build the shellout install command correctly" do
+      profile_path = "/tmp/test.mobileconfig"
+      resource.profile test_profile
+      # Change the profile so it triggers an install
+      all_profiles["_computerlevel"][1]["ProfileUUID"] = "1781fbec-3325-565f-9022-9bb39245d4dd"
+      provider.load_current_resource
+      allow(provider).to receive(:write_profile_to_disk).and_return(profile_path)
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-I", "-F", profile_path).and_return(shell_out_success)
+      provider.action_install
+    end
+
+    it "should fail if there is no identifier inside the profile" do
+      test_profile.delete("PayloadIdentifier")
+      resource.profile test_profile
+      error_message = "The specified profile does not seem to be valid"
+      expect { provider.run_action(:install) }.to raise_error(RuntimeError, error_message)
+    end
+  end
+
+  describe "action_remove" do
+    let(:node) { Chef::Node.new }
+    let(:events) { Chef::EventDispatch::Dispatcher.new }
+    let(:run_context) { Chef::RunContext.new(node, {}, events) }
+    let(:resource) { Chef::Resource::OsxProfile.new("Profile Test", run_context) }
+    let(:provider) { resource.provider_for_action(:remove) }
+    let(:current_resource) { Chef::Resource::OsxProfile.new("Profile Test") }
+    let(:all_profiles) do
+      { "_computerlevel" => [{ "ProfileDisplayName" => "ScreenSaver Settings",
+                               "ProfileIdentifier" => "com.apple.screensaver",
+                               "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+                               "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                                                    "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                                                    "PayloadIdentifier" => "com.apple.screensaver",
+                                                    "PayloadType" => "com.apple.ManagedClient.preferences",
+                                                    "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c108",
+                                                    "PayloadVersion" => 1 }],
+                               "ProfileOrganization" => "Chef",
+                               "ProfileRemovalDisallowed" => "false",
+                               "ProfileType" => "Configuration",
+                               "ProfileUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+                               "ProfileVerificationState" => "unsigned",
+                               "ProfileVersion" => 1 },
+        { "ProfileDisplayName" => "ScreenSaver Settings",
+          "ProfileIdentifier" => "com.testprofile.screensaver",
+          "ProfileInstallDate" => "2015-10-05 23:15:21 +0000",
+          "ProfileItems" => [{ "PayloadContent" => { "PayloadContentManagedPreferences" => { "com.apple.screensaver" => { "Forced" => [{ "mcx_preference_settings" => { "idleTime" => 0 } }] } } },
+                               "PayloadDisplayName" => "Custom: (com.apple.screensaver)",
+                               "PayloadIdentifier" => "com.apple.screensaver",
+                               "PayloadType" => "com.apple.ManagedClient.preferences",
+                               "PayloadUUID" => "73fc30e0-1e57-0131-c32d-000c2944c110",
+                               "PayloadVersion" => 1 }],
+          "ProfileOrganization" => "Chef",
+          "ProfileRemovalDisallowed" => "false",
+          "ProfileType" => "Configuration",
+          "ProfileUUID" => "1781fbec-3325-565f-9022-8aa28135c3cc",
+          "ProfileVerificationState" => "unsigned",
+          "ProfileVersion" => 1 }],
+      }
+    end
+
+    before(:each) do
+      provider.current_resource = current_resource
+      allow(provider).to receive(:get_installed_profiles).and_return(all_profiles)
+    end
+
+    it "should use resource name for identifier when not specified" do
+      resource.profile_name "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider.instance_variable_get(:@new_profile_identifier)).to eql(resource.profile_name)
+    end
+
+    it "should use specified identifier" do
+      resource.identifier "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider.instance_variable_get(:@new_profile_identifier)).to eql(resource.identifier)
+    end
+
+    it "should work with spaces in the identifier" do
+      provider.action = :remove
+      provider.define_resource_requirements
+      expect { provider.process_resource_requirements }.not_to raise_error
+    end
+
+    it "should build the shellout remove command correctly" do
+      resource.identifier "com.testprofile.screensaver"
+      resource.action(:remove)
+      provider.load_current_resource
+      expect(provider).to receive(:shell_out_compacted!).with("/usr/bin/profiles", "-R", "-p", resource.identifier).and_return(shell_out_success)
+      provider.action_remove
+    end
+  end
 end

data/spec/unit/resource/powershell_script_spec.rb

@@ -20,7 +20,7 @@ require "spec_helper"
 
 describe Chef::Resource::PowershellScript do
 
-  before(:each) do
+  let(:resource) do
     node = Chef::Node.new
 
     node.default["kernel"] = {}
@@ -29,26 +29,25 @@ describe Chef::Resource::PowershellScript do
 
     run_context = Chef::RunContext.new(node, nil, nil)
 
-    @resource = Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
+    Chef::Resource::PowershellScript.new("powershell_unit_test", run_context)
   end
 
   it "creates a new Chef::Resource::PowershellScript" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript)
+    expect(resource).to be_a_kind_of(Chef::Resource::PowershellScript)
   end
 
   it "sets convert_boolean_return to false by default" do
-    expect(@resource.convert_boolean_return).to eq(false)
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
   it "returns the value for convert_boolean_return that was set" do
-    @resource.convert_boolean_return true
-    expect(@resource.convert_boolean_return).to eq(true)
-    @resource.convert_boolean_return false
-    expect(@resource.convert_boolean_return).to eq(false)
+    resource.convert_boolean_return true
+    expect(resource.convert_boolean_return).to eq(true)
+    resource.convert_boolean_return false
+    expect(resource.convert_boolean_return).to eq(false)
   end
 
   context "when using guards" do
-    let(:resource) { @resource }
     before(:each) do
       allow(resource).to receive(:run_action)
       allow(resource).to receive(:updated).and_return(true)
@@ -126,28 +125,11 @@ describe Chef::Resource::PowershellScript do
   end
 
   context "as a script running in Windows-based scripting language" do
-    let(:resource_instance) { @resource }
-    let(:resource_instance_name ) { @resource.command }
+    let(:windows_script_resource) { resource }
+    let(:resource_instance_name ) { resource.command }
     let(:resource_name) { :powershell_script }
     let(:interpreter_file_name) { "powershell.exe" }
-    before do
-      allow(@resource).to receive(:default_flags).and_return(nil)
-    end
-    it_behaves_like "a Windows script resource"
-  end
-
-  describe "#flags" do
-    let(:resource) { @resource }
-
-    it "appends user's flags to the defaults" do
-      flags = %q{-Lunch "tacos"}
-      resource.flags = flags
 
-      expect(resource.flags).to eq("#{resource.default_flags} #{flags}")
-    end
-
-    it "uses the defaults when user doesn't provide flags" do
-      expect(resource.flags).to eq(resource.default_flags)
-    end
+    it_behaves_like "a Windows script resource"
   end
 end

data/spec/unit/resource/script_spec.rb

@@ -21,9 +21,14 @@ require "spec_helper"
 
 describe Chef::Resource::Script do
   let(:resource_instance_name) { "fakey_fakerton" }
-  let(:script_resource) { Chef::Resource::Script.new(resource_instance_name) }
   let(:resource_name) { :script }
 
+  let(:script_resource) do
+    run_context = Chef::RunContext.new(Chef::Node.new, nil, nil)
+
+    Chef::Resource::Script.new(resource_instance_name, run_context)
+  end
+
   it "sets the default action as :run" do
     expect(script_resource.action).to eql([:run])
   end

data/spec/unit/resource/windows_feature_powershell_spec.rb

@@ -22,6 +22,7 @@ describe Chef::Resource::WindowsFeaturePowershell do
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
   let(:resource) { Chef::Resource::WindowsFeaturePowershell.new(%w{SNMP DHCP}, run_context) }
+  let(:provider) { resource.provider_for_action(:install) }
 
   it "sets resource name as :windows_feature_powershell" do
     expect(resource.resource_name).to eql(:windows_feature_powershell)
@@ -35,10 +36,6 @@ describe Chef::Resource::WindowsFeaturePowershell do
     expect(resource.feature_name).to eql(%w{snmp dhcp})
   end
 
-  it "sets the default action as :install" do
-    expect(resource.action).to eql([:install])
-  end
-
   it "supports :delete, :install, :remove actions" do
     expect { resource.action :delete }.not_to raise_error
     expect { resource.action :install }.not_to raise_error
@@ -54,4 +51,33 @@ describe Chef::Resource::WindowsFeaturePowershell do
     resource.feature_name "SNMP"
     expect(resource.feature_name).to eql(["snmp"])
   end
+
+  it "install a single feature" do
+    resource.feature_name "snmp"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "install multi feature" do
+    resource.feature_name "SNMP, DHCP"
+    expect { resource.action :install }.not_to raise_error
+  end
+
+  it "does not attempt to install features that have been removed" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+
+    expect(provider.features_to_install).to eq(["dhcp"])
+  end
+
+  it "attempts to install features that have been removed when source is set" do
+    node.default["powershell_features_cache"] ||= {}
+    node.default["powershell_features_cache"]["disabled"] = ["dhcp"]
+    node.default["powershell_features_cache"]["removed"] = ["snmp"]
+    resource.feature_name "dhcp, snmp"
+    resource.source 'D:\\sources\\sxs'
+
+    expect(provider.features_to_install).to eq(%w{dhcp snmp})
+  end
 end

data/spec/unit/role_spec.rb

@@ -259,7 +259,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from JSON" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json"])
       file_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
-      expect(File).to receive(:exists?).with(file_path).exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with(file_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(file_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -268,7 +268,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from a Ruby DSL" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
       rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
-      expect(File).to receive(:exists?).with(rb_path).exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with(rb_path).exactly(1).times.and_return(true)
       expect(File).to receive(:readable?).with(rb_path).exactly(1).times.and_return(true)
       expect(File).to receive(:file?).with(rb_path).exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with(rb_path).and_return(ROLE_DSL)
@@ -280,8 +280,8 @@ describe Chef::Role do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes", "#{Chef::Config[:role_path]}/memes/lolcat.json", "#{Chef::Config[:role_path]}/memes/lolcat.rb"])
       js_path = File.join(Chef::Config[:role_path], "memes/lolcat.json")
       rb_path = File.join(Chef::Config[:role_path], "memes/lolcat.rb")
-      expect(File).to receive(:exists?).with(js_path).exactly(1).times.and_return(true)
-      expect(File).not_to receive(:exists?).with(rb_path)
+      expect(File).to receive(:exist?).with(js_path).exactly(1).times.and_return(true)
+      expect(File).not_to receive(:exist?).with(rb_path)
       expect(IO).to receive(:read).with(js_path).and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -289,19 +289,19 @@ describe Chef::Role do
 
     it "should raise an exception if the file does not exist" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/meme.rb"])
-      expect(File).not_to receive(:exists?)
+      expect(File).not_to receive(:exist?)
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::RoleNotFound)
     end
 
     it "should raise an exception if two files exist with the same name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/lolcat.rb"])
-      expect(File).not_to receive(:exists?)
+      expect(File).not_to receive(:exist?)
       expect { @role.class.from_disk("lolcat") }.to raise_error(Chef::Exceptions::DuplicateRole)
     end
 
     it "should not raise an exception if two files exist with a similar name" do
       expect(Dir).to receive(:glob).and_return(["#{Chef::Config[:role_path]}/memes/lolcat.rb", "#{Chef::Config[:role_path]}/super_lolcat.rb"])
-      expect(File).to receive(:exists?).with("#{Chef::Config[:role_path]}/memes/lolcat.rb").and_return(true)
+      expect(File).to receive(:exist?).with("#{Chef::Config[:role_path]}/memes/lolcat.rb").and_return(true)
       allow_any_instance_of(Chef::Role).to receive(:from_file).with("#{Chef::Config[:role_path]}/memes/lolcat.rb")
       expect { @role.class.from_disk("lolcat") }.not_to raise_error
     end
@@ -317,7 +317,7 @@ describe Chef::Role do
 
     it "should return a Chef::Role object from JSON" do
       expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.json"])
-      expect(File).to receive(:exists?).with("#{root}/lolcat.json").exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with("#{root}/lolcat.json").exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with("#{root}/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -326,7 +326,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from JSON when role is in the second path" do
       expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
       expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.json"])
-      expect(File).to receive(:exists?).with("#{root}/path2/lolcat.json").exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with("#{root}/path2/lolcat.json").exactly(1).times.and_return(true)
       expect(IO).to receive(:read).with("#{root}/path2/lolcat.json").and_return('{"name": "ceiling_cat", "json_class": "Chef::Role" }')
       expect(@role).to be_a_kind_of(Chef::Role)
       @role.class.from_disk("lolcat")
@@ -334,7 +334,7 @@ describe Chef::Role do
 
     it "should return a Chef::Role object from a Ruby DSL" do
       expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return(["#{root}/lolcat.rb"])
-      expect(File).to receive(:exists?).with("#{root}/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with("#{root}/lolcat.rb").exactly(1).times.and_return(true)
       expect(File).to receive(:readable?).with("#{root}/lolcat.rb").and_return(true)
       expect(File).to receive(:file?).with("#{root}/lolcat.rb").and_return(true)
       expect(IO).to receive(:read).with("#{root}/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)
@@ -345,7 +345,7 @@ describe Chef::Role do
     it "should return a Chef::Role object from a Ruby DSL when role is in the second path" do
       expect(Dir).to receive(:glob).with(File.join(root, "**", "**")).exactly(1).times.and_return([])
       expect(Dir).to receive(:glob).with(File.join("#{root}/path2", "**", "**")).exactly(1).times.and_return(["#{root}/path2/lolcat.rb"])
-      expect(File).to receive(:exists?).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(true)
+      expect(File).to receive(:exist?).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(true)
       expect(File).to receive(:readable?).with("#{root}/path2/lolcat.rb").and_return(true)
       expect(File).to receive(:file?).with("#{root}/path2/lolcat.rb").and_return(true)
       expect(IO).to receive(:read).with("#{root}/path2/lolcat.rb").exactly(1).times.and_return(ROLE_DSL)