puppet 5.5.12 → 5.5.13

data/spec/unit/util/windows/api_types_spec.rb

@@ -1,5 +1,4 @@
 # encoding: UTF-8
-#!/usr/bin/env ruby
 
 require 'spec_helper'
 

data/spec/unit/util/windows/eventlog_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 
 require 'puppet/util/windows'
@@ -23,7 +21,7 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
     it "sets a handle to the event log" do
       default_name = Puppet::Util::Windows::String.wide_string('Puppet')
       # return nil explicitly just to reinforce that we're not leaking eventlog handle
-      Puppet::Util::Windows::EventLog.any_instance.expects(:RegisterEventSourceW).with(nil, default_name).returns(nil)
+      expect_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).with(anything, default_name).and_return(nil)
       Puppet::Util::Windows::EventLog.new
     end
 
@@ -31,7 +29,7 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
       before do
         # RegisterEventSourceW will return NULL on failure
         # Stubbing prevents leaking eventlog handle
-        Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(Puppet::Util::Windows::EventLog::NULL_HANDLE)
+        allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(Puppet::Util::Windows::EventLog::NULL_HANDLE)
       end
 
       it "raises an exception warning that the event log failed to open" do
@@ -40,11 +38,11 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
 
       it "passes the exit code to the exception constructor" do
         fake_error = Puppet::Util::Windows::EventLog::EventLogError.new('foo', 87)
-        FFI.stubs(:errno).returns(87)
+        allow(FFI).to receive(:errno).and_return(87)
         # All we're testing here is that the constructor actually receives the exit code from FFI.errno (87)
         # We do so because `expect to...raise_error` doesn't support multiple parameter match arguments
         # We return fake_error just because `raise` expects an exception class
-        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to open Windows eventlog/), 87).returns(fake_error)
+        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to open Windows eventlog/, 87).and_return(fake_error)
         expect { Puppet::Util::Windows::EventLog.open('foo') }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError)
       end
     end
@@ -53,9 +51,9 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
   describe "#close" do
     it "closes the handle to the event log" do
       @handle = "12345"
-      Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(@handle)
+      allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(@handle)
       event_log = Puppet::Util::Windows::EventLog.new
-      event_log.expects(:DeregisterEventSource).with(@handle).returns(1)
+      expect(event_log).to receive(:DeregisterEventSource).with(@handle).and_return(1)
       event_log.close
     end
   end
@@ -68,7 +66,7 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
     context "when an event report fails" do
       before do
         # ReportEventW returns 0 on failure, which is mapped to WIN32_FALSE
-        @event_log.stubs(:ReportEventW).returns(Puppet::Util::Windows::EventLog::WIN32_FALSE)
+        allow(@event_log).to receive(:ReportEventW).and_return(Puppet::Util::Windows::EventLog::WIN32_FALSE)
       end
 
       it "raises an exception warning that the event report failed" do
@@ -77,18 +75,17 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
 
       it "passes the exit code to the exception constructor" do
         fake_error = Puppet::Util::Windows::EventLog::EventLogError.new('foo', 5)
-        FFI.stubs(:errno).returns(5)
+        allow(FFI).to receive(:errno).and_return(5)
         # All we're testing here is that the constructor actually receives the exit code from FFI.errno (5)
         # We do so because `expect to...raise_error` doesn't support multiple parameter match arguments
         # We return fake_error just because `raise` expects an exception class
-        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to report event/), 5).returns(fake_error)
+        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to report event/, 5).and_return(fake_error)
         expect { @event_log.report_event(:data => 'foo', :event_type => Puppet::Util::Windows::EventLog::EVENTLOG_ERROR_TYPE, :event_id => 0x03) }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError)
       end
     end
   end
 
   describe "self.to_native" do
-
     it "raises an exception if the log level is not supported" do
       expect { Puppet::Util::Windows::EventLog.to_native(:foo) }.to raise_error(ArgumentError)
     end

data/spec/unit/util/windows/file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 

data/spec/unit/util/windows/root_certs_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 

data/spec/unit/util/windows/security_descriptor_spec.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/util/windows'
 

data/spec/unit/util/windows/service_spec.rb

@@ -1,13 +1,12 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_windows? do
   require 'puppet/util/windows'
 
   before(:each) do
-    Puppet::Util::Windows::Error.stubs(:format_error_code)
+    allow(Puppet::Util::Windows::Error).to receive(:format_error_code)
       .with(anything)
-      .returns("fake error!")
+      .and_return("fake error!")
   end
 
   def service_state_str(state)
@@ -22,7 +21,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
   # just an expectation of subject::SERVICE_STATUS_PROCESS.new in sequence that
   # returns the value passed in as a param
   def expect_successful_status_query_and_return(query_return)
-    subject::SERVICE_STATUS_PROCESS.expects(:new).in_sequence(status_checks).returns(query_return)
+    expect(subject::SERVICE_STATUS_PROCESS).to receive(:new).and_return(query_return)
   end
 
   def expect_successful_status_queries_and_return(*query_returns)
@@ -39,34 +38,33 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
   # just an expectation of subject::QUERY_SERVICE_CONFIGW.new in sequence that
   # returns the value passed in as a param
   def expect_successful_config_query_and_return(query_return)
-    subject::QUERY_SERVICE_CONFIGW.expects(:new).in_sequence(status_checks).returns(query_return)
+    expect(subject::QUERY_SERVICE_CONFIGW).to receive(:new).and_return(query_return)
   end
 
   let(:subject)      { Puppet::Util::Windows::Service }
-  let(:pointer) { mock() }
-  let(:status_checks) { sequence('status_checks') }
-  let(:mock_service_name) { mock() }
-  let(:service) { mock() }
-  let(:scm) { mock() }
+  let(:pointer) { double() }
+  let(:mock_service_name) { double() }
+  let(:service) { double() }
+  let(:scm) { double() }
 
   before do
-    subject.stubs(:QueryServiceStatusEx).returns(1)
-    subject.stubs(:QueryServiceConfigW).returns(1)
-    subject.stubs(:ChangeServiceConfigW).returns(1)
-    subject.stubs(:OpenSCManagerW).returns(scm)
-    subject.stubs(:OpenServiceW).returns(service)
-    subject.stubs(:CloseServiceHandle)
-    subject.stubs(:EnumServicesStatusExW).returns(1)
-    subject.stubs(:wide_string)
-    subject::SERVICE_STATUS_PROCESS.stubs(:new)
-    subject::QUERY_SERVICE_CONFIGW.stubs(:new)
-    subject::SERVICE_STATUS.stubs(:new).returns({:dwCurrentState => subject::SERVICE_RUNNING})
-    FFI.stubs(:errno).returns(0)
-    FFI::MemoryPointer.stubs(:new).yields(pointer)
-    pointer.stubs(:read_dword)
-    pointer.stubs(:write_dword)
-    pointer.stubs(:size)
-    subject.stubs(:sleep)
+    allow(subject).to receive(:QueryServiceStatusEx).and_return(1)
+    allow(subject).to receive(:QueryServiceConfigW).and_return(1)
+    allow(subject).to receive(:ChangeServiceConfigW).and_return(1)
+    allow(subject).to receive(:OpenSCManagerW).and_return(scm)
+    allow(subject).to receive(:OpenServiceW).and_return(service)
+    allow(subject).to receive(:CloseServiceHandle)
+    allow(subject).to receive(:EnumServicesStatusExW).and_return(1)
+    allow(subject).to receive(:wide_string)
+    allow(subject::SERVICE_STATUS_PROCESS).to receive(:new)
+    allow(subject::QUERY_SERVICE_CONFIGW).to receive(:new)
+    allow(subject::SERVICE_STATUS).to receive(:new).and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+    allow(FFI).to receive(:errno).and_return(0)
+    allow(FFI::MemoryPointer).to receive(:new).and_yield(pointer)
+    allow(pointer).to receive(:read_dword)
+    allow(pointer).to receive(:write_dword)
+    allow(pointer).to receive(:size)
+    allow(subject).to receive(:sleep)
   end
 
   describe "#exists?" do
@@ -81,7 +79,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
       let(:service) { FFI::Pointer::NULL_HANDLE }
 
       it "returns false if it fails to open because the service does not exist" do
-        FFI.stubs(:errno).returns(Puppet::Util::Windows::Service::ERROR_SERVICE_DOES_NOT_EXIST)
+        allow(FFI).to receive(:errno).and_return(Puppet::Util::Windows::Service::ERROR_SERVICE_DOES_NOT_EXIST)
 
         expect(subject.exists?(mock_service_name)).to be false
       end
@@ -113,7 +111,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
     final_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[final_state].to_s
 
     it "raises a Puppet::Error if the service query fails" do
-      subject.expects(:QueryServiceStatusEx).in_sequence(status_checks).returns(FFI::WIN32_FALSE)
+      expect(subject).to receive(:QueryServiceStatusEx).and_return(FFI::WIN32_FALSE)
 
       expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
     end
@@ -132,7 +130,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         { :dwCurrentState => final_state }
       )
 
-      subject.expects(:sleep).with(1)
+      expect(subject).to receive(:sleep).with(1)
 
       subject.send(action, mock_service_name)
     end
@@ -143,7 +141,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         { :dwCurrentState => final_state }
       )
 
-      subject.expects(:sleep).with(10)
+      expect(subject).to receive(:sleep).with(10)
 
       subject.send(action, mock_service_name)
     end
@@ -238,7 +236,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           # This mocks the status query to return the 'final_state' by default. Otherwise,
           # we will fail the tests in the latter parts of the code where we wait for the
           # service to finish transitioning to the 'final_state'.
-          subject::SERVICE_STATUS_PROCESS.stubs(:new).returns(dwCurrentState: final_state)
+          allow(subject::SERVICE_STATUS_PROCESS).to receive(:new).and_return(dwCurrentState: final_state)
 
           # Set our service's initial state
           expect_successful_status_query_and_return(dwCurrentState: unsafe_pending_state)
@@ -264,7 +262,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
       end
 
       it "raises a Puppet::Error if the service query fails" do
-        subject.expects(:QueryServiceStatusEx).in_sequence(status_checks).returns(FFI::WIN32_FALSE)
+        expect(subject).to receive(:QueryServiceStatusEx).and_return(FFI::WIN32_FALSE)
 
         expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
       end
@@ -276,7 +274,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           { :dwCurrentState => final_state }
         )
 
-        subject.expects(:sleep).with(1).twice
+        expect(subject).to receive(:sleep).with(1).twice
 
         subject.send(action, mock_service_name)
       end
@@ -345,7 +343,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         let(:initial_state) { subject::SERVICE_STOPPED }
         let(:mock_state_transition) do
           lambda do
-            subject.stubs(:StartServiceW).returns(1)
+            allow(subject).to receive(:StartServiceW).and_return(1)
           end
         end
       end
@@ -353,7 +351,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
       it "raises a Puppet::Error if StartServiceW returns false" do
         expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_STOPPED)
   
-        subject.expects(:StartServiceW).returns(FFI::WIN32_FALSE)
+        expect(subject).to receive(:StartServiceW).and_return(FFI::WIN32_FALSE)
 
         expect { subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
@@ -364,7 +362,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           { dwCurrentState: subject::SERVICE_RUNNING }
         )
   
-        subject.expects(:StartServiceW).returns(1)
+        expect(subject).to receive(:StartServiceW).and_return(1)
   
         subject.start(mock_service_name)
       end
@@ -397,7 +395,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         let(:initial_state) { subject::SERVICE_RUNNING }
         let(:mock_state_transition) do
           lambda do
-            subject.stubs(:ControlService).returns(1)
+            allow(subject).to receive(:ControlService).and_return(1)
           end
         end
       end
@@ -405,7 +403,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
       it "raises a Puppet::Error if ControlService returns false" do
         expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_RUNNING)
 
-        subject.stubs(:ControlService).returns(FFI::WIN32_FALSE)
+        allow(subject).to receive(:ControlService).and_return(FFI::WIN32_FALSE)
 
         expect { subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
@@ -416,7 +414,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           { dwCurrentState: subject::SERVICE_STOPPED }
         )
 
-        subject.expects(:ControlService).returns(1)
+        expect(subject).to receive(:ControlService).and_return(1)
 
         subject.stop(mock_service_name)
       end
@@ -458,7 +456,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
             # performing the transition (in case it is in SERVICE_PAUSE_PENDING).
             expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
 
-            subject.stubs(:ControlService).returns(1)
+            allow(subject).to receive(:ControlService).and_return(1)
           end
         end
       end
@@ -468,11 +466,11 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           # This mocks the status query to return the SERVICE_RUNNING state by default.
           # Otherwise, we will fail the tests in the latter parts of the code where we
           # wait for the service to finish transitioning to the 'SERVICE_RUNNING' state.
-          subject::SERVICE_STATUS_PROCESS.stubs(:new).returns(dwCurrentState: subject::SERVICE_RUNNING)
+          allow(subject::SERVICE_STATUS_PROCESS).to receive(:new).and_return(dwCurrentState: subject::SERVICE_RUNNING)
 
           expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSE_PENDING)
 
-          subject.stubs(:ControlService).returns(1)
+          allow(subject).to receive(:ControlService).and_return(1)
         end
 
         include_examples "a service action waiting on a pending transition", service::SERVICE_PAUSE_PENDING do
@@ -484,7 +482,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
         expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
 
-        subject.stubs(:ControlService).returns(FFI::WIN32_FALSE)
+        allow(subject).to receive(:ControlService).and_return(FFI::WIN32_FALSE)
 
         expect { subject.resume(mock_service_name) }.to raise_error(Puppet::Error)
       end
@@ -496,7 +494,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           { dwCurrentState: subject::SERVICE_RUNNING }
         )
 
-        subject.expects(:ControlService).returns(1)
+        expect(subject).to receive(:ControlService).and_return(1)
 
         subject.resume(mock_service_name)
       end
@@ -566,7 +564,6 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
     end
 
     context "when the service can be opened" do
-
       # We need to guard this section explicitly since rspec will always
       # construct all examples, even if it isn't going to run them.
       if Puppet.features.microsoft_windows?
@@ -583,9 +580,10 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
           end
         end
       end
+
       it "raises a puppet error if the service query fails" do
-        subject.expects(:QueryServiceConfigW).in_sequence(status_checks)
-        subject.expects(:QueryServiceConfigW).in_sequence(status_checks).returns(FFI::WIN32_FALSE)
+        expect(subject).to receive(:QueryServiceConfigW)
+        expect(subject).to receive(:QueryServiceConfigW).and_return(FFI::WIN32_FALSE)
         expect{ subject.service_start_type(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
@@ -610,7 +608,7 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
 
     context "when the service can be opened" do
       it "Raises an error on an unsuccessful change" do
-        subject.expects(:ChangeServiceConfigW).returns(FFI::WIN32_FALSE)
+        expect(subject).to receive(:ChangeServiceConfigW).and_return(FFI::WIN32_FALSE)
         expect{ subject.set_startup_mode(mock_service_name, :SERVICE_DEMAND_START) }.to raise_error(Puppet::Error)
       end
     end
@@ -628,36 +626,36 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
 
     context "when the service control manager is open" do
       let(:cursor) { [ 'svc1', 'svc2', 'svc3' ] }
-      let(:svc1name_ptr) { mock() }
-      let(:svc2name_ptr) { mock() }
-      let(:svc3name_ptr) { mock() }
-      let(:svc1displayname_ptr) { mock() }
-      let(:svc2displayname_ptr) { mock() }
-      let(:svc3displayname_ptr) { mock() }
+      let(:svc1name_ptr) { double() }
+      let(:svc2name_ptr) { double() }
+      let(:svc3name_ptr) { double() }
+      let(:svc1displayname_ptr) { double() }
+      let(:svc2displayname_ptr) { double() }
+      let(:svc3displayname_ptr) { double() }
       let(:svc1) { { :lpServiceName => svc1name_ptr, :lpDisplayName => svc1displayname_ptr, :ServiceStatusProcess => 'foo' } }
       let(:svc2) { { :lpServiceName => svc2name_ptr, :lpDisplayName => svc2displayname_ptr, :ServiceStatusProcess => 'foo' } }
       let(:svc3) { { :lpServiceName => svc3name_ptr, :lpDisplayName => svc3displayname_ptr, :ServiceStatusProcess => 'foo' } }
 
       it "Raises an error if EnumServicesStatusExW fails" do
-        subject.expects(:EnumServicesStatusExW).in_sequence(pointer_sequence)
-        subject.expects(:EnumServicesStatusExW).in_sequence(pointer_sequence).returns(FFI::WIN32_FALSE)
+        expect(subject).to receive(:EnumServicesStatusExW)
+        expect(subject).to receive(:EnumServicesStatusExW).and_return(FFI::WIN32_FALSE)
         expect{ subject.services }.to raise_error(Puppet::Error)
       end
 
       it "Reads the buffer using pointer arithmetic to create a hash of service entries" do
         # the first read_dword is for reading the bytes required, let that return 3 too.
         # the second read_dword will actually read the number of services returned
-        pointer.expects(:read_dword).twice.returns(3)
-        FFI::Pointer.expects(:new).with(subject::ENUM_SERVICE_STATUS_PROCESSW, pointer).returns(cursor)
-        subject::ENUM_SERVICE_STATUS_PROCESSW.expects(:new).in_sequence(pointer_sequence).with('svc1').returns(svc1)
-        subject::ENUM_SERVICE_STATUS_PROCESSW.expects(:new).in_sequence(pointer_sequence).with('svc2').returns(svc2)
-        subject::ENUM_SERVICE_STATUS_PROCESSW.expects(:new).in_sequence(pointer_sequence).with('svc3').returns(svc3)
-        svc1name_ptr.expects(:read_arbitrary_wide_string_up_to).returns('svc1')
-        svc2name_ptr.expects(:read_arbitrary_wide_string_up_to).returns('svc2')
-        svc3name_ptr.expects(:read_arbitrary_wide_string_up_to).returns('svc3')
-        svc1displayname_ptr.expects(:read_arbitrary_wide_string_up_to).returns('service 1')
-        svc2displayname_ptr.expects(:read_arbitrary_wide_string_up_to).returns('service 2')
-        svc3displayname_ptr.expects(:read_arbitrary_wide_string_up_to).returns('service 3')
+        expect(pointer).to receive(:read_dword).twice.and_return(3)
+        expect(FFI::Pointer).to receive(:new).with(subject::ENUM_SERVICE_STATUS_PROCESSW, pointer).and_return(cursor)
+        expect(subject::ENUM_SERVICE_STATUS_PROCESSW).to receive(:new).with('svc1').and_return(svc1)
+        expect(subject::ENUM_SERVICE_STATUS_PROCESSW).to receive(:new).with('svc2').and_return(svc2)
+        expect(subject::ENUM_SERVICE_STATUS_PROCESSW).to receive(:new).with('svc3').and_return(svc3)
+        expect(svc1name_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('svc1')
+        expect(svc2name_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('svc2')
+        expect(svc3name_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('svc3')
+        expect(svc1displayname_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('service 1')
+        expect(svc2displayname_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('service 2')
+        expect(svc3displayname_ptr).to receive(:read_arbitrary_wide_string_up_to).and_return('service 3')
         expect(subject.services).to eq({
           'svc1' => { :display_name => 'service 1', :service_status_process => 'foo' },
           'svc2' => { :display_name => 'service 2', :service_status_process => 'foo' },

data/spec/unit/util/windows/sid_spec.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 require 'spec_helper'
 
 describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows? do
@@ -72,12 +71,12 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should return a SID for a passed user or group name" do
-      subject.expects(:name_to_principal).with('testers').returns stub(:sid => 'S-1-5-32-547')
+      expect(subject).to receive(:name_to_principal).with('testers').and_return(double(:sid => 'S-1-5-32-547'))
       expect(subject.name_to_sid('testers')).to eq('S-1-5-32-547')
     end
 
     it "should return a SID for a passed fully-qualified user or group name" do
-      subject.expects(:name_to_principal).with('MACHINE\testers').returns stub(:sid => 'S-1-5-32-547')
+      expect(subject).to receive(:name_to_principal).with('MACHINE\testers').and_return(double(:sid => 'S-1-5-32-547'))
       expect(subject.name_to_sid('MACHINE\testers')).to eq('S-1-5-32-547')
     end
 
@@ -100,7 +99,6 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     describe "with non-US languages" do
-
       UMLAUT = [195, 164].pack('c*').force_encoding(Encoding::UTF_8)
       let(:username) { SecureRandom.uuid.to_s.gsub(/\-/, '')[0..13] + UMLAUT }
 
@@ -165,20 +163,20 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
   context "#ads_to_principal" do
     it "should raise an error for non-WIN32OLE input" do
       expect {
-        subject.ads_to_principal(stub('WIN32OLE', { :Name => 'foo' }))
+        subject.ads_to_principal(double('WIN32OLE', { :Name => 'foo' }))
       }.to raise_error(Puppet::Error, /ads_object must be an IAdsUser or IAdsGroup instance/)
     end
 
     it "should raise an error for an empty byte array in the objectSID property" do
       expect {
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => [], :Name => '', :ole_respond_to? => true }))
+        subject.ads_to_principal(double('WIN32OLE', { :objectSID => [], :Name => '', :ole_respond_to? => true }))
       }.to raise_error(Puppet::Error, /Octet string must be an array of bytes/)
     end
 
     it "should raise an error for a malformed byte array" do
       expect {
         invalid_octet = [2]
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => invalid_octet, :Name => '', :ole_respond_to? => true }))
+        subject.ads_to_principal(double('WIN32OLE', { :objectSID => invalid_octet, :Name => '', :ole_respond_to? => true }))
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
         expect(error.code).to eq(87) # ERROR_INVALID_PARAMETER
@@ -189,7 +187,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
       expect {
         # S-1-1-1 is a valid SID that will not resolve
         valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-        subject.ads_to_principal(stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => unknown_name, :ole_respond_to? => true }))
+        subject.ads_to_principal(double('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => unknown_name, :ole_respond_to? => true }))
       }.to raise_error do |error|
         expect(error).to be_a(Puppet::Error)
         expect(error.cause.code).to eq(1332) # ERROR_NONE_MAPPED
@@ -199,7 +197,7 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     it "should return a Principal object even when the SID is unresolvable, as long as the Name matches" do
       # S-1-1-1 is a valid SID that will not resolve
       valid_octet_invalid_user = [1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0]
-      unresolvable_user = stub('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => 'S-1-1-1', :ole_respond_to? => true })
+      unresolvable_user = double('WIN32OLE', { :objectSID => valid_octet_invalid_user, :Name => 'S-1-1-1', :ole_respond_to? => true })
       principal = subject.ads_to_principal(unresolvable_user)
 
       expect(principal).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
@@ -213,13 +211,13 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
 
     it "should return a Puppet::Util::Windows::SID::Principal instance for any valid sid" do
       system_bytes = [1, 1, 0, 0, 0, 0, 0, 5, 18, 0, 0, 0]
-      adsuser = stub('WIN32OLE', { :objectSID => system_bytes, :Name => 'SYSTEM', :ole_respond_to? => true })
+      adsuser = double('WIN32OLE', { :objectSID => system_bytes, :Name => 'SYSTEM', :ole_respond_to? => true })
       expect(subject.ads_to_principal(adsuser)).to be_an_instance_of(Puppet::Util::Windows::SID::Principal)
     end
 
     it "should properly convert an array of bytes for a well-known non-localized SID, ignoring the Name from the WIN32OLE object" do
       bytes = [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
-      adsuser = stub('WIN32OLE', { :objectSID => bytes, :Name => unknown_name, :ole_respond_to? => true })
+      adsuser = double('WIN32OLE', { :objectSID => bytes, :Name => unknown_name, :ole_respond_to? => true })
       converted = subject.ads_to_principal(adsuser)
 
       expect(converted).to be_an_instance_of Puppet::Util::Windows::SID::Principal
@@ -288,8 +286,8 @@ describe "Puppet::Util::Windows::SID", :if => Puppet.features.microsoft_windows?
     end
 
     it "should raise if the conversion fails" do
-      subject.expects(:string_to_sid_ptr).with(sid).
-        raises(Puppet::Util::Windows::Error.new("Failed to convert string SID: #{sid}", Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED))
+      expect(subject).to receive(:string_to_sid_ptr).with(sid).
+        and_raise(Puppet::Util::Windows::Error.new("Failed to convert string SID: #{sid}", Puppet::Util::Windows::Error::ERROR_ACCESS_DENIED))
 
       expect {
         subject.string_to_sid_ptr(sid) {|ptr| }