puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

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

@@ -1,89 +1,66 @@
 # encoding: UTF-8
+#!/usr/bin/env ruby
 
 require 'spec_helper'
 
-describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
+describe "FFI::MemoryPointer", :if => Puppet::Util::Platform.windows? do
   # use 2 bad bytes at end so we have even number of bytes / characters
-  let(:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
-  let(:bad_string_bytes) { bad_string.bytes.to_a }
-  let(:a_wide_bytes) { "A".encode(Encoding::UTF_16LE).bytes.to_a }
-  let(:b_wide_bytes) { "B".encode(Encoding::UTF_16LE).bytes.to_a }
+  let (:bad_string) { "hello invalid world".encode(Encoding::UTF_16LE) + "\xDD\xDD".force_encoding(Encoding::UTF_16LE) }
+  let (:bad_string_bytes) { bad_string.bytes.to_a }
 
   context "read_wide_string" do
     let (:string) { "foo_bar" }
 
     it "should properly roundtrip a given string" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        expect(ptr.read_wide_string(string.length)).to eq(string)
+        read_string = ptr.read_wide_string(string.length)
       end
+
+      expect(read_string).to eq(string)
     end
 
     it "should return a given string in UTF-8" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
         read_string = ptr.read_wide_string(string.length)
-        expect(read_string.encoding).to eq(Encoding::UTF_8)
       end
+
+      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should raise an error and emit a debug message when receiving a string containing invalid bytes in the destination encoding" do
-      Puppet[:log_level] = 'debug'
+      # enable a debug output sink to local string array
+      Puppet.debug = true
+      arraydest = []
+      Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
+
+      read_string = nil
 
       expect {
         FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
           # uchar here is synonymous with byte
           ptr.put_array_of_uchar(0, bad_string_bytes)
 
-          ptr.read_wide_string(bad_string.length)
+          read_string = ptr.read_wide_string(bad_string.length)
         end
       }.to raise_error(Encoding::InvalidByteSequenceError)
 
-      expect(@logs.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
+      expect(read_string).to be_nil
+      expect(arraydest.last.message).to eq("Unable to convert value #{bad_string.dump} to encoding UTF-8 due to #<Encoding::InvalidByteSequenceError: \"\\xDD\\xDD\" on UTF-16LE>")
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
+      read_string = nil
+
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
-        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, false, :invalid => :replace)
-        expect(read_string).to eq("hello invalid world\uFFFD")
+        read_string = ptr.read_wide_string(bad_string.length, Encoding::UTF_8, :invalid => :replace)
       end
-    end
 
-    it "raises an IndexError if asked to read more characters than there are bytes allocated" do
-      expect {
-        FFI::MemoryPointer.new(:byte, 1) do |ptr|
-          ptr.read_wide_string(1) # 1 wchar = 2 bytes
-        end
-      }.to raise_error(IndexError, /out of bounds/)
-    end
-
-    it "raises an IndexError if asked to read a negative number of characters" do
-      expect {
-        FFI::MemoryPointer.new(:byte, 1) do |ptr|
-          ptr.read_wide_string(-1)
-        end
-      }.to raise_error(IndexError, /out of bounds/)
-    end
-
-    it "returns an empty string if asked to read 0 characters" do
-      FFI::MemoryPointer.new(:byte, 1) do |ptr|
-        expect(ptr.read_wide_string(0)).to eq("")
-      end
-    end
-
-    it "returns a substring if asked to read fewer characters than are in the byte array" do
-      FFI::MemoryPointer.new(:byte, 4) do |ptr|
-        ptr.write_array_of_uint8("AB".encode('UTF-16LE').bytes.to_a)
-        expect(ptr.read_wide_string(1)).to eq("A")
-      end
-    end
-
-    it "preserves wide null characters in the string" do
-      FFI::MemoryPointer.new(:byte, 6) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes + [0, 0] + b_wide_bytes)
-        expect(ptr.read_wide_string(3)).to eq("A\x00B")
-      end
+      expect(read_string).to eq("hello invalid world\uFFFD")
     end
   end
 
@@ -93,92 +70,52 @@ describe "FFI::MemoryPointer", :if => Puppet.features.microsoft_windows? do
     let (:double_null_string) { string + "\x00\x00" }
 
     it "should read a short single null terminated string" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
+        read_string = ptr.read_arbitrary_wide_string_up_to()
       end
-    end
 
-    it "should read a short double null terminated string" do
-      FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
-      end
+      expect(read_string).to eq(string)
     end
 
-    it "detects trailing single null wchar" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
-
-        expect(ptr.read_arbitrary_wide_string_up_to).to eq(string)
-      end
-    end
-
-    it "detects trailing double null wchar" do
+    it "should read a short double null terminated string" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(double_null_string) do |ptr|
-        expect(ptr).to receive(:read_wide_string).with(string.length, anything, anything, anything).and_call_original
-
-        expect(ptr.read_arbitrary_wide_string_up_to(512, :double_null)).to eq(string)
-      end
-    end
-
-    it "should raises an IndexError if max_length is negative" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(-1)
-        }.to raise_error(IndexError, /out of bounds/)
+        read_string = ptr.read_arbitrary_wide_string_up_to(512, :double_null)
       end
-    end
 
-    it "should return an empty string when the max_length is 0" do
-      FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(0)).to eq("")
-      end
+      expect(read_string).to eq(string)
     end
 
     it "should return a string of max_length characters when specified" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(single_null_string) do |ptr|
-        expect(ptr.read_arbitrary_wide_string_up_to(3)).to eq(string[0..2])
+        read_string = ptr.read_arbitrary_wide_string_up_to(3)
       end
+
+      expect(read_string).to eq(string[0..2])
     end
 
     it "should return wide strings in UTF-8" do
+      read_string = nil
       FFI::MemoryPointer.from_string_to_wide_string(string) do |ptr|
-        read_string = ptr.read_arbitrary_wide_string_up_to
-        expect(read_string.encoding).to eq(Encoding::UTF_8)
+        read_string = ptr.read_arbitrary_wide_string_up_to()
       end
+
+      expect(read_string.encoding).to eq(Encoding::UTF_8)
     end
 
     it "should not raise an error when receiving a string containing invalid bytes in the destination encoding, when specifying :invalid => :replace" do
+      read_string = nil
+
       FFI::MemoryPointer.new(:byte, bad_string_bytes.count) do |ptr|
         # uchar here is synonymous with byte
         ptr.put_array_of_uchar(0, bad_string_bytes)
 
         read_string = ptr.read_arbitrary_wide_string_up_to(ptr.size / 2, :single_null, :invalid => :replace)
-        expect(read_string).to eq("hello invalid world\uFFFD")
-      end
-    end
-
-    it "should raise an IndexError if there isn't a null terminator" do
-      # This only works when using a memory pointer with a known number of cells
-      # and size per cell, but not arbitrary Pointers
-      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes)
-
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(42)
-        }.to raise_error(IndexError, /out of bounds/)
       end
-    end
-
-    it "should raise an IndexError if there isn't a double null terminator" do
-      # This only works when using a memory pointer with a known number of cells
-      # and size per cell, but not arbitrary Pointers
-      FFI::MemoryPointer.new(:wchar, 1) do |ptr|
-        ptr.write_array_of_uint8(a_wide_bytes)
 
-        expect {
-          ptr.read_arbitrary_wide_string_up_to(42, :double_null)
-        }.to raise_error(IndexError, /out of bounds/)
-      end
+      expect(read_string).to eq("hello invalid world\uFFFD")
     end
   end
 end

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

@@ -1,8 +1,10 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
 require 'puppet/util/windows'
 
-describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windows? do
+describe Puppet::Util::Windows::EventLog, :if => Puppet::Util::Platform.windows? do
 
   before(:each) { @event_log = Puppet::Util::Windows::EventLog.new }
   after(:each) { @event_log.close }
@@ -21,7 +23,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
-      expect_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).with(anything, default_name).and_return(nil)
+      Puppet::Util::Windows::EventLog.any_instance.expects(:RegisterEventSourceW).with(nil, default_name).returns(nil)
       Puppet::Util::Windows::EventLog.new
     end
 
@@ -29,7 +31,7 @@ describe Puppet::Util::Windows::EventLog, :if => Puppet.features.microsoft_windo
       before do
         # RegisterEventSourceW will return NULL on failure
         # Stubbing prevents leaking eventlog handle
-        allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(Puppet::Util::Windows::EventLog::NULL_HANDLE)
+        Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(Puppet::Util::Windows::EventLog::NULL_HANDLE)
       end
 
       it "raises an exception warning that the event log failed to open" do
@@ -38,11 +40,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)
-        allow(FFI).to receive(:errno).and_return(87)
+        FFI.stubs(:errno).returns(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
-        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to open Windows eventlog/, 87).and_return(fake_error)
+        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to open Windows eventlog/), 87).returns(fake_error)
         expect { Puppet::Util::Windows::EventLog.open('foo') }.to raise_error(Puppet::Util::Windows::EventLog::EventLogError)
       end
     end
@@ -51,9 +53,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"
-      allow_any_instance_of(Puppet::Util::Windows::EventLog).to receive(:RegisterEventSourceW).and_return(@handle)
+      Puppet::Util::Windows::EventLog.any_instance.stubs(:RegisterEventSourceW).returns(@handle)
       event_log = Puppet::Util::Windows::EventLog.new
-      expect(event_log).to receive(:DeregisterEventSource).with(@handle).and_return(1)
+      event_log.expects(:DeregisterEventSource).with(@handle).returns(1)
       event_log.close
     end
   end
@@ -66,7 +68,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
-        allow(@event_log).to receive(:ReportEventW).and_return(Puppet::Util::Windows::EventLog::WIN32_FALSE)
+        @event_log.stubs(:ReportEventW).returns(Puppet::Util::Windows::EventLog::WIN32_FALSE)
       end
 
       it "raises an exception warning that the event report failed" do
@@ -75,17 +77,18 @@ 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)
-        allow(FFI).to receive(:errno).and_return(5)
+        FFI.stubs(:errno).returns(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
-        expect(Puppet::Util::Windows::EventLog::EventLogError).to receive(:new).with(/failed to report event/, 5).and_return(fake_error)
+        Puppet::Util::Windows::EventLog::EventLogError.expects(:new).with(regexp_matches(/failed to report event/), 5).returns(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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/util/windows'
 

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

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

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

@@ -1,7 +1,9 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 require 'puppet/util/windows'
 
-describe "Puppet::Util::Windows::SecurityDescriptor", :if => Puppet.features.microsoft_windows? do
+describe "Puppet::Util::Windows::SecurityDescriptor", :if => Puppet::Util::Platform.windows? do
   let(:system_sid) { Puppet::Util::Windows::SID::LocalSystem }
   let(:admins_sid) { Puppet::Util::Windows::SID::BuiltinAdministrators }
   let(:group_sid) { Puppet::Util::Windows::SID::Nobody }

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

@@ -1,18 +1,9 @@
+#!/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
-    allow(Puppet::Util::Windows::Error).to receive(:format_error_code)
-      .with(anything)
-      .and_return("fake error!")
-  end
-
-  def service_state_str(state)
-    Puppet::Util::Windows::Service::SERVICE_STATES[state].to_s
-  end
-
   # The following should emulate a successful call to the private function
   # query_status that returns the value of query_return. This should give
   # us a way to mock changes in service status.
@@ -21,13 +12,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)
-    expect(subject::SERVICE_STATUS_PROCESS).to receive(:new).and_return(query_return)
-  end
-
-  def expect_successful_status_queries_and_return(*query_returns)
-    query_returns.each do |query_return|
-      expect_successful_status_query_and_return(query_return)
-    end
+    subject::SERVICE_STATUS_PROCESS.expects(:new).in_sequence(status_checks).returns(query_return)
   end
 
   # The following should emulate a successful call to the private function
@@ -38,471 +23,237 @@ 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)
-    expect(subject::QUERY_SERVICE_CONFIGW).to receive(:new).and_return(query_return)
-  end
-
-  def expect_successful_config_query2_and_return(param, query_return)
-    expect(param).to receive(:new).and_return(query_return)
+    subject::QUERY_SERVICE_CONFIGW.expects(:new).in_sequence(status_checks).returns(query_return)
   end
 
   let(:subject)      { Puppet::Util::Windows::Service }
-  let(:pointer) { double() }
-  let(:mock_service_name) { double() }
-  let(:service) { double() }
-  let(:scm) { double() }
+  let(:pointer) { mock() }
+  let(:status_checks) { sequence('status_checks') }
+  let(:mock_service_name) { mock() }
+  let(:service) { mock() }
+  let(:scm) { mock() }
 
   before do
-    allow(subject).to receive(:QueryServiceStatusEx).and_return(1)
-    allow(subject).to receive(:QueryServiceConfigW).and_return(1)
-    allow(subject).to receive(:QueryServiceConfig2W).and_return(1)
-    allow(subject).to receive(:ChangeServiceConfigW).and_return(1)
-    allow(subject).to receive(:ChangeServiceConfig2W).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)
+    subject.stubs(:QueryServiceStatusEx).returns(1)
+    subject.stubs(:QueryServiceConfigW).returns(1)
+    subject.stubs(:StartServiceW).returns(1)
+    subject.stubs(:ControlService).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})
+    Puppet::Util::Windows::Error.stubs(:new).raises(Puppet::Error.new('fake error'))
+    FFI::MemoryPointer.stubs(:new).yields(pointer)
+    pointer.stubs(:read_dword)
+    pointer.stubs(:write_dword)
+    pointer.stubs(:size)
   end
 
-  describe "#exists?" do
+  describe "#start" do
+
     context "when the service control manager cannot be opened" do
       let(:scm) { FFI::Pointer::NULL_HANDLE }
       it "raises a puppet error" do
-        expect{ subject.exists?(mock_service_name) }.to raise_error(Puppet::Error)
+        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
     context "when the service cannot be opened" do
       let(:service) { FFI::Pointer::NULL_HANDLE }
-
-      it "returns false if it fails to open because the service does not exist" do
-        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
-
-      it "raises a puppet error if it fails to open for some other reason" do
-        expect{ subject.exists?(mock_service_name) }.to raise_error(Puppet::Error)
-      end
-    end
-
-    context "when the service can be opened" do
-      it "returns true" do
-        expect(subject.exists?(mock_service_name)).to be true
+      it "raises a puppet error" do
+        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
-  end
-
-  # This shared example contains the unit tests for the wait_on_pending_state
-  # helper as used by service actions like #start and #stop. Before including
-  # this shared example, be sure to mock out any intermediate calls prior to
-  # the pending transition, and make sure that the post-condition _after_ those
-  # intermediate calls leaves the service in the pending state. Before including
-  # this example in your tests, be sure to define the following variables in a `let`
-  # context:
-  #     * action -- The service action
-  shared_examples "a service action waiting on a pending transition" do |pending_state|
-    pending_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[pending_state].to_s
-
-    final_state = Puppet::Util::Windows::Service::FINAL_STATES[pending_state]
-    final_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[final_state].to_s
-
-    it "raises a Puppet::Error if the service query fails" do
-      expect(subject).to receive(:QueryServiceStatusEx).and_return(FFI::WIN32_FALSE)
-
-      expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
-    end
-
-    it "raises a Puppet::Error if the service unexpectedly transitions to a state other than #{pending_state_str} or #{final_state_str}" do
-      invalid_state = (subject::SERVICE_STATES.keys - [pending_state, final_state]).first
-
-      expect_successful_status_query_and_return(dwCurrentState: invalid_state)
-
-      expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
-    end
-
-    it "waits for at least 1 second if the wait_hint/10 is < 1 second" do
-      expect_successful_status_queries_and_return(
-        { :dwCurrentState => pending_state, :dwWaitHint => 0, :dwCheckPoint => 1 },
-        { :dwCurrentState => final_state }
-      )
-
-      expect(subject).to receive(:sleep).with(1)
-
-      subject.send(action, mock_service_name)
-    end
-
-    it "waits for at most 10 seconds if wait_hint/10 is > 10 seconds" do
-      expect_successful_status_queries_and_return(
-        { :dwCurrentState => pending_state, :dwWaitHint => 1000000, :dwCheckPoint => 1 },
-        { :dwCurrentState => final_state }
-      )
-
-      expect(subject).to receive(:sleep).with(10)
-
-      subject.send(action, mock_service_name)
-    end
-
-    it "does not raise an error if the service makes any progress while transitioning to #{final_state_str}" do
-      expect_successful_status_queries_and_return(
-        # The three "pending_state" statuses simulate the scenario where the service
-        # makes some progress during the transition right when Puppet's about to
-        # time out.
-        { :dwCurrentState => pending_state, :dwWaitHint => 100000, :dwCheckPoint => 1 },
-        { :dwCurrentState => pending_state, :dwWaitHint => 100000, :dwCheckPoint => 1 },
-        { :dwCurrentState => pending_state, :dwWaitHint => 100000, :dwCheckPoint => 2 },
-
-        { :dwCurrentState => final_state }
-      )
-
-      expect { subject.send(action, mock_service_name) }.to_not raise_error
-    end
 
-    it "raises a Puppet::Error if it times out while waiting for the transition to #{final_state_str}" do
-      31.times do
-        expect_successful_status_query_and_return(
-          dwCurrentState: pending_state,
-          dwWaitHint: 10000,
-          dwCheckPoint: 1
-        )
+    context "when the service can be opened and is in the stopped state" do
+      before do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
       end
 
-      expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
-    end
-  end
-
-  # This shared example contains the unit tests for the transition_service_state
-  # helper, which is the helper that all of our service actions like #start, #stop
-  # delegate to. Including these tests under a shared example lets us include them in each of
-  # those service action's unit tests. Before including this example in your tests, be
-  # sure to define the following variables in a `let` context:
-  #     * initial_state         -- The initial state of the service prior to performing the state
-  #                                transition
-  #
-  #     * mock_state_transition -- A lambda that mocks the state transition. This should mock
-  #                                any code in the block that's passed to the
-  #                                transition_service_state helper
-  #
-  # See the unit tests for the #start method to see how this shared example's
-  # included.
-  #
-  shared_examples "a service action that transitions the service state" do |action, valid_initial_states, pending_state, final_state|
-    valid_initial_states_str = valid_initial_states.map do |state|
-      Puppet::Util::Windows::Service::SERVICE_STATES[state]
-    end.join(', ')
-    pending_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[pending_state].to_s
-    final_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[final_state].to_s
-
-    it "noops if the service is already in the #{final_state} state" do
-      expect_successful_status_query_and_return(dwCurrentState: final_state)
-
-      expect { subject.send(action, mock_service_name) }.to_not raise_error
-    end
-
-    # invalid_initial_states will be empty for the #stop action
-    invalid_initial_states = Puppet::Util::Windows::Service::SERVICE_STATES.keys - valid_initial_states - [final_state]
-    unless invalid_initial_states.empty?
-      it "raises a Puppet::Error if the service's initial state is not one of #{valid_initial_states_str}" do
-        invalid_initial_state = invalid_initial_states.first
-        expect_successful_status_query_and_return(dwCurrentState: invalid_initial_state)
-  
-        expect{ subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
+      it "Starts the service once the service reports SERVICE_RUNNING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.start(mock_service_name)
       end
-    end
 
-    context "when there's a pending transition to the #{final_state} state" do
-      before(:each) do
-        expect_successful_status_query_and_return(dwCurrentState: pending_state)
+      it "Raises an error if after calling StartServiceW the service is not in RUNNING or START_PENDING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_PAUSED})
+        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
 
-      include_examples "a service action waiting on a pending transition", pending_state do
-        let(:action) { action }
+      it "raises a puppet error if StartServiceW returns false" do
+        subject.expects(:StartServiceW).returns(FFI::WIN32_FALSE)
+        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
-    # If the service action accepts an unsafe pending state as one of the service's
-    # initial states, then we need to test that the action waits for the service to
-    # transition from that unsafe pending state before doing anything else.
-    unsafe_pending_states = valid_initial_states & Puppet::Util::Windows::Service::UNSAFE_PENDING_STATES
-    unless unsafe_pending_states.empty?
-      unsafe_pending_state = unsafe_pending_states.first
-      unsafe_pending_state_str = Puppet::Util::Windows::Service::SERVICE_STATES[unsafe_pending_state]
-
-      context "waiting for a service with #{unsafe_pending_state_str} as its initial state" do
-        before(:each) do
-          # 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'.
-          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)
-
-          mock_state_transition.call
-        end
-
-        include_examples "a service action waiting on a pending transition", unsafe_pending_state do
-          let(:action) { action }
-        end
+    context "when the service hasn't stopped yet:" do
+      it "waits, then queries again until SERVICE_STOPPED" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(3).twice
+        subject.start(mock_service_name)
       end
-    end
-
-    # reads e.g. "waiting for the service to transition to the SERVICE_RUNNING state after executing the 'start' action"
-    #
-    # NOTE: This is really unit testing the wait_on_state_transition helper
-    context "waiting for the service to transition to the #{final_state_str} state after executing the '#{action}' action" do
-      before(:each) do
-        # Set our service's initial state prior to performing the state transition
-        expect_successful_status_query_and_return(dwCurrentState: initial_state)
 
-        mock_state_transition.call
+      it "waits for at least 1 second if wait hint/10 is < 1 second" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(1)
+        subject.start(mock_service_name)
       end
 
-      it "raises a Puppet::Error if the service query fails" do
-        expect(subject).to receive(:QueryServiceStatusEx).and_return(FFI::WIN32_FALSE)
-
-        expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
+      it "waits for at most 10 seconds if wait hint/10 is > 10 seconds" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 1000000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(10)
+        subject.start(mock_service_name)
       end
 
-      it "waits, then queries again until it transitions to #{final_state_str}" do
-        expect_successful_status_queries_and_return(
-          { :dwCurrentState => initial_state },
-          { :dwCurrentState => initial_state },
-          { :dwCurrentState => final_state }
-        )
-
-        expect(subject).to receive(:sleep).with(1).twice
-
-        subject.send(action, mock_service_name)
+      it "raises a puppet error if the service query fails" do
+        subject.expects(:QueryServiceStatusEx).in_sequence(status_checks).returns(1)
+        subject.expects(:QueryServiceStatusEx).in_sequence(status_checks).returns(FFI::WIN32_FALSE)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
       end
 
-      context "when it transitions to the #{pending_state_str} state" do
-        before(:each) do
-          expect_successful_status_query_and_return(dwCurrentState: pending_state)
-        end
-
-        include_examples "a service action waiting on a pending transition", pending_state do
-          let(:action) { action }
-        end
+      it "raises a puppet error if the services configured dwWaitHint is 0, 30 seconds have passed and dwCheckPoint hasn't increased" do
+        # the number of times here is a little strange: there are 31 and 32 status queries sleeps because:
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0}).times(31)
+        subject.expects(:sleep).times(30).with(1)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
       end
 
-      it "raises a Puppet::Error if it times out while waiting for the transition to #{final_state_str}" do
-        31.times do
-          expect_successful_status_query_and_return(dwCurrentState: initial_state)
-        end
+      it "raises a puppet error if the services configured dwWaitHint has passed and dwCheckPoint hasn't increased" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 40000, :dwCheckPoint => 0}).times(11)
+        subject.expects(:sleep).times(10).with(4)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
+      end
 
-        expect { subject.send(action, mock_service_name) }.to raise_error(Puppet::Error)
+      it "Does not raise an error if the service makes progress" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 2})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 30})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 0, :dwCheckPoint => 98})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).times(5).with(1)
+        expect{subject.start(mock_service_name)}.to_not raise_error
       end
     end
-  end
 
-  describe "#start" do
-    # rspec will still try to load the tests even though
-    # the :if => Puppet.features.microsoft_windows? filter
-    # is passed-in to the top-level describe block on
-    # non-Windows platforms; it just won't run them. However
-    # on these platforms, the loading will fail because this
-    # test uses a shared example that references variables
-    # from the Windows::Service module when building the unit
-    # tests, which is only available on Windows platforms.
-    # Thus, we add the next here to ensure that rspec does not
-    # attempt to load our test code. This is OK for us to do
-    # because we do not want to run these tests on non-Windows
-    # platforms.
-    next unless Puppet.features.microsoft_windows?
+    context "when the service ends up in START_PENDING:" do
+      it "waits, then queries again until SERVICE_RUNNING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(3).twice
+        subject.start(mock_service_name)
+      end
 
-    context "when the service control manager cannot be opened" do
-      let(:scm) { FFI::Pointer::NULL_HANDLE }
-      it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+      it "waits for at least 1 second if wait hint/10 is < 1 second" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(1)
+        subject.start(mock_service_name)
       end
-    end
 
-    context "when the service cannot be opened" do
-      let(:service) { FFI::Pointer::NULL_HANDLE }
-      it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+      it "waits for at most 10 seconds if wait hint/10 is > 10 seconds" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 1000000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).with(10)
+        subject.start(mock_service_name)
       end
-    end
 
-    context "when the service can be opened" do
-      # Can't use rspec's subject here because that
-      # can only be referenced inside an 'it' block.
-      service = Puppet::Util::Windows::Service
-      valid_initial_states = [
-        service::SERVICE_STOP_PENDING,
-        service::SERVICE_STOPPED,
-        service::SERVICE_START_PENDING
-      ]
-      final_state = service::SERVICE_RUNNING
-  
-      include_examples "a service action that transitions the service state", :start, valid_initial_states, service::SERVICE_START_PENDING, final_state do
-        let(:initial_state) { subject::SERVICE_STOPPED }
-        let(:mock_state_transition) do
-          lambda do
-            allow(subject).to receive(:StartServiceW).and_return(1)
-          end
-        end
+      it "raises a puppet error if the service's configured dwWaitHint has passed and dwCheckPoint hasn't increased" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 40000, :dwCheckPoint => 0}).times(11)
+        subject.expects(:sleep).times(10).with(4)
+        expect{subject.start(mock_service_name)}.to raise_error(Puppet::Error)
       end
-  
-      it "raises a Puppet::Error if StartServiceW returns false" do
-        expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_STOPPED)
-  
-        expect(subject).to receive(:StartServiceW).and_return(FFI::WIN32_FALSE)
-
-        expect { subject.start(mock_service_name) }.to raise_error(Puppet::Error)
-      end
-  
-      it "starts the service" do
-        expect_successful_status_queries_and_return(
-          { dwCurrentState: subject::SERVICE_STOPPED },
-          { dwCurrentState: subject::SERVICE_RUNNING }
-        )
-  
-        expect(subject).to receive(:StartServiceW).and_return(1)
-  
-        subject.start(mock_service_name)
+
+      it "Does not raise an error if the service makes progress" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 0})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 2})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 30})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 0, :dwCheckPoint => 98})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        subject.expects(:sleep).times(5).with(1)
+        expect{subject.start(mock_service_name)}.to_not raise_error
       end
     end
   end
 
   describe "#stop" do
-    next unless Puppet.features.microsoft_windows?
-
     context "when the service control manager cannot be opened" do
       let(:scm) { FFI::Pointer::NULL_HANDLE }
       it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+        expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
     context "when the service cannot be opened" do
       let(:service) { FFI::Pointer::NULL_HANDLE }
       it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+        expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
-    context "when the service can be opened" do
-      service = Puppet::Util::Windows::Service
-      valid_initial_states = service::SERVICE_STATES.keys - [service::SERVICE_STOPPED]
-      final_state = service::SERVICE_STOPPED
-  
-      include_examples "a service action that transitions the service state", :stop, valid_initial_states, service::SERVICE_STOP_PENDING, final_state do
-        let(:initial_state) { subject::SERVICE_RUNNING }
-        let(:mock_state_transition) do
-          lambda do
-            allow(subject).to receive(:ControlService).and_return(1)
-          end
-        end
+    context "when the service can be opened and is in the running state:" do
+      before do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
       end
 
-      it "raises a Puppet::Error if ControlService returns false" do
-        expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_RUNNING)
-
-        allow(subject).to receive(:ControlService).and_return(FFI::WIN32_FALSE)
-
-        expect { subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
-      end
-  
-      it "stops the service" do
-        expect_successful_status_queries_and_return(
-          { dwCurrentState: subject::SERVICE_RUNNING },
-          { dwCurrentState: subject::SERVICE_STOPPED }
-        )
-
-        expect(subject).to receive(:ControlService).and_return(1)
-
+      it "Sends the SERVICE_CONTROL_STOP to the service once the service reports SERVICE_RUNNING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
         subject.stop(mock_service_name)
       end
-    end
-  end
-
-  describe "#resume" do
-    next unless Puppet.features.microsoft_windows?
 
-    context "when the service control manager cannot be opened" do
-      let(:scm) { FFI::Pointer::NULL_HANDLE }
-      it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+      it "Raises an error if after calling ControlService the service is not in STOPPED or STOP_PENDING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_PAUSED})
+        expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
-    end
 
-    context "when the service cannot be opened" do
-      let(:service) { FFI::Pointer::NULL_HANDLE }
-      it "raises a puppet error" do
-        expect{ subject.start(mock_service_name) }.to raise_error(Puppet::Error)
+      it "raises a puppet error if ControlService returns false" do
+        subject.expects(:ControlService).returns(FFI::WIN32_FALSE)
+        expect{ subject.stop(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
 
-    context "when the service can be opened" do
-      service = Puppet::Util::Windows::Service
-      valid_initial_states = [
-        service::SERVICE_PAUSE_PENDING,
-        service::SERVICE_PAUSED,
-        service::SERVICE_CONTINUE_PENDING
-      ]
-      final_state = service::SERVICE_RUNNING
-  
-      include_examples "a service action that transitions the service state", :resume, valid_initial_states, service::SERVICE_CONTINUE_PENDING, final_state do
-        let(:initial_state) { service::SERVICE_PAUSED }
-        let(:mock_state_transition) do
-          lambda do
-            # We need to mock the status query because in the block for #resume, we
-            # wait for the service to enter the SERVICE_PAUSED state prior to
-            # performing the transition (in case it is in SERVICE_PAUSE_PENDING).
-            expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
-
-            allow(subject).to receive(:ControlService).and_return(1)
-          end
-        end
-      end
-
-      context "waiting for the SERVICE_PAUSE_PENDING => SERVICE_PAUSED transition to finish before resuming it" do
-        before(:each) do
-          # 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.
-          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)
-
-          allow(subject).to receive(:ControlService).and_return(1)
-        end
-
-        include_examples "a service action waiting on a pending transition", service::SERVICE_PAUSE_PENDING do
-          let(:action) { :resume }
-        end
-      end
-
-      it "raises a Puppet::Error if ControlService returns false" do
-        expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
-        expect_successful_status_query_and_return(dwCurrentState: subject::SERVICE_PAUSED)
-
-        allow(subject).to receive(:ControlService).and_return(FFI::WIN32_FALSE)
-
-        expect { subject.resume(mock_service_name) }.to raise_error(Puppet::Error)
+    # No need to retest much of the wait functionality here, since
+    # both stop and start use the wait_for_pending_transition helper
+    # which is tested in the start unit tests.
+    context "when the service hasn't started yet:" do
+      it "waits, then queries again until SERVICE_STOPPED" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_START_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        subject.expects(:sleep).with(3).twice
+        subject.stop(mock_service_name)
       end
-  
-      it "resumes the service" do
-        expect_successful_status_queries_and_return(
-          { dwCurrentState: subject::SERVICE_PAUSED },
-          { dwCurrentState: subject::SERVICE_PAUSED },
-          { dwCurrentState: subject::SERVICE_RUNNING }
-        )
-
-        expect(subject).to receive(:ControlService).and_return(1)
+    end
 
-        subject.resume(mock_service_name)
+    context "when the service ends up in STOP_PENDING:" do
+      it "waits, then queries again until SERVICE_RUNNING" do
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_RUNNING})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 1})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOP_PENDING, :dwWaitHint => 30000, :dwCheckPoint => 50})
+        expect_successful_status_query_and_return({:dwCurrentState => subject::SERVICE_STOPPED})
+        subject.expects(:sleep).with(3).twice
+        subject.stop(mock_service_name)
       end
     end
   end
@@ -570,6 +321,7 @@ 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?
@@ -582,17 +334,13 @@ describe "Puppet::Util::Windows::Service", :if => Puppet.features.microsoft_wind
         }.each do |start_type_name, start_type|
           it "queries the service and returns the service start type #{start_type_name}" do
             expect_successful_config_query_and_return({:dwStartType => start_type})
-            if start_type_name == :SERVICE_AUTO_START
-              expect_successful_config_query2_and_return(subject::SERVICE_DELAYED_AUTO_START_INFO, {:fDelayedAutostart => 0})
-            end
             expect(subject.service_start_type(mock_service_name)).to eq(start_type_name)
           end
         end
       end
-
       it "raises a puppet error if the service query fails" do
-        expect(subject).to receive(:QueryServiceConfigW)
-        expect(subject).to receive(:QueryServiceConfigW).and_return(FFI::WIN32_FALSE)
+        subject.expects(:QueryServiceConfigW).in_sequence(status_checks)
+        subject.expects(:QueryServiceConfigW).in_sequence(status_checks).returns(FFI::WIN32_FALSE)
         expect{ subject.service_start_type(mock_service_name) }.to raise_error(Puppet::Error)
       end
     end
@@ -617,7 +365,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
-        expect(subject).to receive(:ChangeServiceConfigW).and_return(FFI::WIN32_FALSE)
+        subject.expects(:ChangeServiceConfigW).returns(FFI::WIN32_FALSE)
         expect{ subject.set_startup_mode(mock_service_name, :SERVICE_DEMAND_START) }.to raise_error(Puppet::Error)
       end
     end
@@ -635,36 +383,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) { double() }
-      let(:svc2name_ptr) { double() }
-      let(:svc3name_ptr) { double() }
-      let(:svc1displayname_ptr) { double() }
-      let(:svc2displayname_ptr) { double() }
-      let(:svc3displayname_ptr) { double() }
+      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(: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
-        expect(subject).to receive(:EnumServicesStatusExW)
-        expect(subject).to receive(:EnumServicesStatusExW).and_return(FFI::WIN32_FALSE)
+        subject.expects(:EnumServicesStatusExW).in_sequence(pointer_sequence)
+        subject.expects(:EnumServicesStatusExW).in_sequence(pointer_sequence).returns(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
-        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')
+        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(subject.services).to eq({
           'svc1' => { :display_name => 'service 1', :service_status_process => 'foo' },
           'svc2' => { :display_name => 'service 2', :service_status_process => 'foo' },