chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/guard_interpreter/resource_guard_interpreter_spec.rb

@@ -29,28 +29,118 @@ describe Chef::GuardInterpreter::ResourceGuardInterpreter do
 
   let(:run_context) { Chef::RunContext.new(node, nil, nil) }
 
-  let(:resource) do
-    resource = Chef::Resource.new("powershell_unit_test", run_context)
-    resource.stub(:run_action)
-    resource.stub(:updated).and_return(true)
-    resource
+  let(:parent_resource) do
+    parent_resource = Chef::Resource.new("powershell_unit_test", run_context)
+    allow(parent_resource).to receive(:run_action)
+    allow(parent_resource).to receive(:updated).and_return(true)
+    parent_resource
   end
 
+  let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "echo hi", nil) }
 
   describe "get_interpreter_resource" do
     it "allows the guard interpreter to be set to Chef::Resource::Script" do
-      resource.guard_interpreter(:script)
-      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.not_to raise_error
+      parent_resource.guard_interpreter(:script)
+      expect { guard_interpreter }.not_to raise_error
     end
-    
+
     it "allows the guard interpreter to be set to Chef::Resource::PowershellScript derived indirectly from Chef::Resource::Script" do
-      resource.guard_interpreter(:powershell_script)
-      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.not_to raise_error
+      parent_resource.guard_interpreter(:powershell_script)
+      expect { guard_interpreter }.not_to raise_error
     end
-    
+
     it "raises an exception if guard_interpreter is set to a resource not derived from Chef::Resource::Script" do
-      resource.guard_interpreter(:file)
-      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(resource, "echo hi", nil) }.to raise_error(ArgumentError)
+      parent_resource.guard_interpreter(:file)
+      expect { guard_interpreter }.to raise_error(ArgumentError, 'Specified guard interpreter class Chef::Resource::File must be a kind of Chef::Resource::Execute resource')
+    end
+
+    context "when the resource cannot be found for the platform" do
+      before do
+        expect(Chef::Resource).to receive(:resource_for_node).with(:foobar, node).and_return(nil)
+      end
+
+      it "raises an exception" do
+        parent_resource.guard_interpreter(:foobar)
+        expect { guard_interpreter }.to raise_error(ArgumentError, 'Specified guard_interpreter resource foobar unknown for this platform')
+      end
+    end
+
+    it "fails when parent_resource is nil" do
+      expect { Chef::GuardInterpreter::ResourceGuardInterpreter.new(nil, "echo hi", nil) }.to raise_error(ArgumentError, /Node for guard resource parent must not be nil/)
+    end
+
+  end
+
+  describe "#evaluate" do
+    let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "echo hi", {}) }
+    let(:parent_resource) do
+      parent_resource = Chef::Resource.new("execute resource", run_context)
+      parent_resource.guard_interpreter(:execute)
+      parent_resource
+    end
+
+    it "successfully evaluates the resource" do
+      expect(guard_interpreter.evaluate).to eq(true)
+    end
+
+    describe "script command opts switch" do
+      let(:command_opts) { {} }
+      let(:guard_interpreter) { Chef::GuardInterpreter::ResourceGuardInterpreter.new(parent_resource, "exit 0", command_opts) }
+
+      context "resource is a Script" do
+        context "and guard_interpreter is a :script" do
+          let(:parent_resource) do
+            parent_resource = Chef::Resource::Script.new("resource", run_context)
+            # Ruby scripts are cross platform to both Linux and Windows
+            parent_resource.guard_interpreter(:ruby)
+            parent_resource
+          end
+
+          let(:shell_out) {
+            instance_double(Mixlib::ShellOut, :live_stream => true, :run_command => true, :error! => nil)
+          }
+
+          before do
+            # TODO for some reason Windows is failing on executing a ruby script
+            expect(Mixlib::ShellOut).to receive(:new) do |*args|
+              expect(args[0]).to match(/^"ruby"/)
+              shell_out
+            end
+          end
+
+          it "merges to :code" do
+            expect(command_opts).to receive(:merge).with({:code => "exit 0"}).and_call_original
+            expect(guard_interpreter.evaluate).to eq(true)
+          end
+        end
+
+        context "and guard_interpreter is :execute" do
+          let(:parent_resource) do
+            parent_resource = Chef::Resource::Script.new("resource", run_context)
+            parent_resource.guard_interpreter(:execute)
+            parent_resource
+          end
+
+          it "merges to :code" do
+            expect(command_opts).to receive(:merge).with({:command => "exit 0"}).and_call_original
+            expect(guard_interpreter.evaluate).to eq(true)
+          end
+        end
+      end
+
+      context "resource is not a Script" do
+        let(:parent_resource) do
+          parent_resource = Chef::Resource::Execute.new("resource", run_context)
+          parent_resource.guard_interpreter(:execute)
+          parent_resource
+        end
+
+        it "merges to :command" do
+          expect(command_opts).to receive(:merge).with({:command => "exit 0"}).and_call_original
+          expect(guard_interpreter.evaluate).to eq(true)
+        end
+      end
+
     end
   end
 end

data/spec/unit/guard_interpreter_spec.rb

@@ -0,0 +1,41 @@
+#
+# Author:: Steven Danna (steve@chef.io)
+# Copyright:: Copyright (c) 2015 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::GuardInterpreter do
+  describe "#for_resource" do
+    let (:resource) { Chef::Resource.new("foo")}
+
+    it "returns a DefaultGuardInterpreter if the resource has guard_interpreter set to :default" do
+      resource.guard_interpreter :default
+      interpreter = Chef::GuardInterpreter.for_resource(resource, "", {})
+      expect(interpreter.class).to eq(Chef::GuardInterpreter::DefaultGuardInterpreter)
+    end
+
+    it "returns a ResourceGuardInterpreter if the resource has guard_interpreter set to !:default" do
+      resource.guard_interpreter :foobar
+      # Mock the resource guard interpreter to avoid having to set up a lot of state
+      # currently we are only testing that we get the correct class of object back
+      rgi = double("Chef::GuardInterpreter::ResourceGuardInterpreter")
+      allow(Chef::GuardInterpreter::ResourceGuardInterpreter).to receive(:new).and_return(rgi)
+      interpreter = Chef::GuardInterpreter.for_resource(resource, "", {})
+      expect(interpreter).to eq(rgi)
+    end
+  end
+end

data/spec/unit/handler/json_file_spec.rb

@@ -24,12 +24,12 @@ describe Chef::Handler::JsonFile do
   end
 
   it "accepts arbitrary config options" do
-    @handler.config[:the_sun].should == "will rise"
+    expect(@handler.config[:the_sun]).to eq("will rise")
   end
 
   it "creates the directory where the reports will be saved" do
-    FileUtils.should_receive(:mkdir_p).with('/tmp/foobarbazqux')
-    File.should_receive(:chmod).with(00700, '/tmp/foobarbazqux')
+    expect(FileUtils).to receive(:mkdir_p).with('/tmp/foobarbazqux')
+    expect(File).to receive(:chmod).with(00700, '/tmp/foobarbazqux')
     @handler.build_report_dir
   end
 
@@ -39,25 +39,25 @@ describe Chef::Handler::JsonFile do
       @events = Chef::EventDispatch::Dispatcher.new
       @run_status = Chef::RunStatus.new(@node, @events)
       @expected_time = Time.now
-      Time.stub(:now).and_return(@expected_time, @expected_time + 5)
+      allow(Time).to receive(:now).and_return(@expected_time, @expected_time + 5)
       @run_status.start_clock
       @run_status.stop_clock
       @run_context = Chef::RunContext.new(@node, {}, @events)
       @run_status.run_context = @run_context
       @run_status.exception = Exception.new("Boy howdy!")
       @file_mock = StringIO.new
-      File.stub(:open).and_yield(@file_mock)
+      allow(File).to receive(:open).and_yield(@file_mock)
     end
 
 
     it "saves run status data to a file as JSON" do
-      @handler.should_receive(:build_report_dir)
+      expect(@handler).to receive(:build_report_dir)
       @handler.run_report_unsafe(@run_status)
       reported_data = Chef::JSONCompat.from_json(@file_mock.string)
-      reported_data['exception'].should == "Exception: Boy howdy!"
-      reported_data['start_time'].should == @expected_time.to_s
-      reported_data['end_time'].should == (@expected_time + 5).to_s
-      reported_data['elapsed_time'].should == 5
+      expect(reported_data['exception']).to eq("Exception: Boy howdy!")
+      expect(reported_data['start_time']).to eq(@expected_time.to_s)
+      expect(reported_data['end_time']).to eq((@expected_time + 5).to_s)
+      expect(reported_data['elapsed_time']).to eq(5)
     end
 
   end

data/spec/unit/handler_spec.rb

@@ -42,54 +42,54 @@ describe Chef::Handler do
       @run_status.run_context = @run_context
       @start_time = Time.now
       @end_time = @start_time + 4.2
-      Time.stub(:now).and_return(@start_time, @end_time)
+      allow(Time).to receive(:now).and_return(@start_time, @end_time)
       @run_status.start_clock
       @run_status.stop_clock
     end
 
     it "has a shortcut for the exception" do
-      @handler.exception.should == @exception
+      expect(@handler.exception).to eq(@exception)
     end
 
     it "has a shortcut for the backtrace" do
-      @handler.backtrace.should == @backtrace
+      expect(@handler.backtrace).to eq(@backtrace)
     end
 
     it "has a shortcut for all resources" do
-      @handler.all_resources.should == @all_resources
+      expect(@handler.all_resources).to eq(@all_resources)
     end
 
     it "has a shortcut for just the updated resources" do
-      @handler.updated_resources.should == [@all_resources.first]
+      expect(@handler.updated_resources).to eq([@all_resources.first])
     end
 
     it "has a shortcut for the start time" do
-      @handler.start_time.should == @start_time
+      expect(@handler.start_time).to eq(@start_time)
     end
 
     it "has a shortcut for the end time" do
-      @handler.end_time.should == @end_time
+      expect(@handler.end_time).to eq(@end_time)
     end
 
     it "has a shortcut for the elapsed time" do
-      @handler.elapsed_time.should == 4.2
+      expect(@handler.elapsed_time).to eq(4.2)
     end
 
     it "has a shortcut for the node" do
-      @handler.node.should == @node
+      expect(@handler.node).to eq(@node)
     end
 
     it "has a shortcut for the run context" do
-      @handler.run_context.should == @run_context
+      expect(@handler.run_context).to eq(@run_context)
     end
 
     it "has a shortcut for the success? and failed? predicates" do
-      @handler.success?.should be_false # becuase there's an exception
-      @handler.failed?.should be_true
+      expect(@handler.success?).to be_falsey # because there's an exception
+      expect(@handler.failed?).to be_truthy
     end
 
     it "has a shortcut to the hash representation of the run status" do
-      @handler.data.should == @run_status.to_hash
+      expect(@handler.data).to eq(@run_status.to_hash)
     end
   end
 
@@ -100,16 +100,16 @@ describe Chef::Handler do
         $report_ran = true
         raise Exception, "I died the deth"
       end
-      lambda {@handler.run_report_safely(@run_status)}.should_not raise_error
-      $report_ran.should be_true
+      expect {@handler.run_report_safely(@run_status)}.not_to raise_error
+      expect($report_ran).to be_truthy
     end
     it "does not fail if the report handler does not raise an exception" do
       $report_ran = false
       def @handler.report
         $report_ran = true
       end
-      lambda {@handler.run_report_safely(@run_status)}.should_not raise_error
-      $report_ran.should be_true
+      expect {@handler.run_report_safely(@run_status)}.not_to raise_error
+      expect($report_ran).to be_truthy
     end
   end
 
@@ -123,46 +123,46 @@ describe Chef::Handler do
       @run_status.run_context = @run_context
       @start_time = Time.now
       @end_time = @start_time + 4.2
-      Time.stub(:now).and_return(@start_time, @end_time)
+      allow(Time).to receive(:now).and_return(@start_time, @end_time)
       @run_status.start_clock
       @run_status.stop_clock
     end
 
     it "has a shortcut for all resources" do
-      @handler.all_resources.should == @all_resources
+      expect(@handler.all_resources).to eq(@all_resources)
     end
 
     it "has a shortcut for just the updated resources" do
-      @handler.updated_resources.should == [@all_resources.first]
+      expect(@handler.updated_resources).to eq([@all_resources.first])
     end
 
     it "has a shortcut for the start time" do
-      @handler.start_time.should == @start_time
+      expect(@handler.start_time).to eq(@start_time)
     end
 
     it "has a shortcut for the end time" do
-      @handler.end_time.should == @end_time
+      expect(@handler.end_time).to eq(@end_time)
     end
 
     it "has a shortcut for the elapsed time" do
-      @handler.elapsed_time.should == 4.2
+      expect(@handler.elapsed_time).to eq(4.2)
     end
 
     it "has a shortcut for the node" do
-      @handler.node.should == @node
+      expect(@handler.node).to eq(@node)
     end
 
     it "has a shortcut for the run context" do
-      @handler.run_context.should == @run_context
+      expect(@handler.run_context).to eq(@run_context)
     end
 
     it "has a shortcut for the success? and failed? predicates" do
-      @handler.success?.should be_true
-      @handler.failed?.should be_false
+      expect(@handler.success?).to be_truthy
+      expect(@handler.failed?).to be_falsey
     end
 
     it "has a shortcut to the hash representation of the run status" do
-      @handler.data.should == @run_status.to_hash
+      expect(@handler.data).to eq(@run_status.to_hash)
     end
   end
 
@@ -170,45 +170,45 @@ describe Chef::Handler do
   describe "when running a start handler" do
     before do
       @start_time = Time.now
-      Time.stub(:now).and_return(@start_time)
+      allow(Time).to receive(:now).and_return(@start_time)
       @run_status.start_clock
     end
 
     it "should not have all resources" do
-      @handler.all_resources.should be_false
+      expect(@handler.all_resources).to be_falsey
     end
 
     it "should not have updated resources" do
-      @handler.updated_resources.should be_false
+      expect(@handler.updated_resources).to be_falsey
     end
 
     it "has a shortcut for the start time" do
-      @handler.start_time.should == @start_time
+      expect(@handler.start_time).to eq(@start_time)
     end
 
     it "does not have a shortcut for the end time" do
-      @handler.end_time.should be_false
+      expect(@handler.end_time).to be_falsey
     end
 
     it "does not have a shortcut for the elapsed time" do
-      @handler.elapsed_time.should be_false
+      expect(@handler.elapsed_time).to be_falsey
     end
 
     it "has a shortcut for the node" do
-      @handler.node.should == @node
+      expect(@handler.node).to eq(@node)
     end
 
     it "does not have a shortcut for the run context" do
-      @handler.run_context.should be_false
+      expect(@handler.run_context).to be_falsey
     end
 
     it "has a shortcut for the success? and failed? predicates" do
-      @handler.success?.should be_true # for some reason this is true
-      @handler.failed?.should be_false
+      expect(@handler.success?).to be_truthy # for some reason this is true
+      expect(@handler.failed?).to be_falsey
     end
 
     it "has a shortcut to the hash representation of the run status" do
-      @handler.data.should == @run_status.to_hash
+      expect(@handler.data).to eq(@run_status.to_hash)
     end
   end
 

data/spec/unit/http/basic_client_spec.rb

@@ -35,7 +35,7 @@ describe "HTTP Connection" do
     end
 
     it "should set an open timeout" do
-      subject.build_http_client.open_timeout.should_not be_nil
+      expect(subject.build_http_client.open_timeout).not_to be_nil
     end
   end
 
@@ -52,12 +52,12 @@ describe "HTTP Connection" do
 
       it "should contain the host" do
         proxy_uri = subject.proxy_uri
-        proxy_uri.host.should == proxy_host
+        expect(proxy_uri.host).to eq(proxy_host)
       end
 
       it "should contain the port" do
         proxy_uri = subject.proxy_uri
-        proxy_uri.port.should == proxy_port
+        expect(proxy_uri.port).to eq(proxy_port)
       end
     end
 

data/spec/unit/http/http_request_spec.rb

@@ -25,31 +25,31 @@ describe Chef::HTTP::HTTPRequest do
     it "should not include port 80 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com'), '')
 
-      request.headers['Host'].should eql('dummy.com')
+      expect(request.headers['Host']).to eql('dummy.com')
     end
 
     it "should not include explicit port 80 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com:80'), '')
 
-      request.headers['Host'].should eql('dummy.com')
+      expect(request.headers['Host']).to eql('dummy.com')
     end
 
     it "should include explicit port 8000 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com:8000'), '')
 
-      request.headers['Host'].should eql('dummy.com:8000')
+      expect(request.headers['Host']).to eql('dummy.com:8000')
     end
 
     it "should include explicit 443 port in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com:443'), '')
 
-      request.headers['Host'].should eql('dummy.com:443')
+      expect(request.headers['Host']).to eql('dummy.com:443')
     end
 
     it "should pass on explicit Host header unchanged" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com:8000'), '', { 'Host' => 'yourhost.com:8888' })
 
-      request.headers['Host'].should eql('yourhost.com:8888')
+      expect(request.headers['Host']).to eql('yourhost.com:8888')
     end
 
   end
@@ -59,25 +59,25 @@ describe Chef::HTTP::HTTPRequest do
     it "should not include port 443 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('https://dummy.com'), '')
 
-      request.headers['Host'].should eql('dummy.com')
+      expect(request.headers['Host']).to eql('dummy.com')
     end
 
     it "should include explicit port 80 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('https://dummy.com:80'), '')
 
-      request.headers['Host'].should eql('dummy.com:80')
+      expect(request.headers['Host']).to eql('dummy.com:80')
     end
 
     it "should include explicit port 8000 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('https://dummy.com:8000'), '')
 
-      request.headers['Host'].should eql('dummy.com:8000')
+      expect(request.headers['Host']).to eql('dummy.com:8000')
     end
 
     it "should not include explicit port 443 in Host header" do
       request = Chef::HTTP::HTTPRequest.new(:GET, URI('https://dummy.com:443'), '')
 
-      request.headers['Host'].should eql('dummy.com')
+      expect(request.headers['Host']).to eql('dummy.com')
     end
 
   end
@@ -85,7 +85,7 @@ describe Chef::HTTP::HTTPRequest do
   it "should pass on explicit Host header unchanged" do
     request = Chef::HTTP::HTTPRequest.new(:GET, URI('http://dummy.com:8000'), '', { 'Host' => 'myhost.com:80' })
 
-    request.headers['Host'].should eql('myhost.com:80')
+    expect(request.headers['Host']).to eql('myhost.com:80')
   end
 
 end