puppet 5.5.6-x64-mingw32 → 5.5.7-x64-mingw32

data/spec/unit/provider/group/aix_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe 'Puppet::Type::Group::Provider::Aix' do
+  let(:provider_class) { Puppet::Type.type(:group).provider(:aix) }
+
+  let(:resource) do
+    Puppet::Type.type(:group).new(
+      :name   => 'test_aix_user',
+      :ensure => :present
+    )
+  end
+  let(:provider) do
+    provider_class.new(resource)
+  end
+
+  describe '.find' do
+    let(:groups) do
+      objects = [
+        { :name => 'group1', :id => '1' },
+        { :name => 'group2', :id => '2' }
+      ]
+
+      objects
+    end
+
+    let(:ia_module_args) { [ '-R', 'module' ] }
+
+    let(:expected_group) do
+      {
+        :name => 'group1',
+        :gid  => 1
+      }
+    end
+
+    before(:each) do
+      provider_class.stubs(:list_all).with(ia_module_args).returns(groups)
+    end
+
+    it 'raises an ArgumentError if the group does not exist' do
+      expect do
+        provider_class.find('non_existent_group', ia_module_args)
+      end.to raise_error do |error|
+        expect(error).to be_a(ArgumentError)
+
+        expect(error.message).to match('non_existent_group')
+      end
+    end
+
+    it 'can find the group when passed-in a group name' do
+      expect(provider_class.find('group1', ia_module_args)).to eql(expected_group)
+    end
+
+    it 'can find the group when passed-in the gid' do
+      expect(provider_class.find(1, ia_module_args)).to eql(expected_group)
+    end
+  end
+end

data/spec/unit/provider/group/pw_spec.rb

@@ -71,11 +71,5 @@ describe provider_class do
       provider.expects(:execute).with(all_of(includes("-M"), includes("user2")), has_entry(:custom_environment, {}))
       provider.members = "user2"
     end
-
-    it "should use -M with all the given users when the members property is changed with an array" do
-      resource[:members] = ["user1", "user2"]
-      provider.expects(:execute).with(all_of(includes("-M"), includes("user3,user4")), has_entry(:custom_environment, {}))
-      provider.members = ["user3", "user4"]
-    end
   end
 end

data/spec/unit/provider/group/windows_adsi_spec.rb

@@ -49,25 +49,25 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     describe "#members_insync?" do
       it "should return true for same lists of members" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
         current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
+          'user1',
+          'user2',
+          'user2'
         ]
         expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
       end
@@ -91,9 +91,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when current and should contain the same users in a different order" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
+            'user1',
+            'user2',
+            'user3'
           ]
           expect(provider.members_insync?(current, ['user3', 'user1', 'user2'])).to be_truthy
         end
@@ -104,21 +104,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return false when should is nil" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, nil)).to be_falsey
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return false when current contains members and should is empty" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -129,16 +129,16 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return false when should user(s) are not the only items in the current" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_falsey
         end
 
         it "should return false when current user(s) is not empty and should is an empty list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, [])).to be_falsey
         end
@@ -156,21 +156,21 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when should is nil" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, nil)).to be_truthy
         end
 
         it "should return false when current contains different users than should" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, ['user2'])).to be_falsey
         end
 
         it "should return true when current contains members and should is empty" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
+            'user1'
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
@@ -181,25 +181,25 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when current user(s) contains at least the should list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user1'])).to be_truthy
         end
 
         it "should return true when current user(s) is not empty and should is an empty list" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, [])).to be_truthy
         end
 
         it "should return true when current user(s) contains at least the should list, even unordered" do
           current = [
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
+            'user3',
+            'user1',
+            'user2'
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
@@ -238,13 +238,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
     it "should be able to provide a list of members" do
       provider.group.stubs(:members).returns ['user1', 'user2', 'user3']
+      Puppet::Util::Windows::ADSI::User.stubs(:name_sid_hash)
+        .with(provider.group.members)
+        .returns({ 'user1' => '', 'user2' => '', 'user3' => '' })
 
       expect(provider.members).to match_array(['user1', 'user2', 'user3'])
     end
 
     it "should be able to set group members" do
-      provider.group.stubs(:members).returns ['user1', 'user2']
-
       member_sids = [
         stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
         stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
@@ -259,7 +260,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       provider.group.expects(:remove_member_sids).with(member_sids[0])
       provider.group.expects(:add_member_sids).with(member_sids[2])
 
-      provider.members = ['user2', 'user3']
+      provider.members = 'user2,user3'
     end
   end
 
@@ -268,12 +269,13 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       resource[:members] = ['user1', 'user2']
 
       group = stub 'group'
+      group.stubs(:members).returns([])
       Puppet::Util::Windows::ADSI::Group.expects(:create).with('testers').returns group
 
       create = sequence('create')
       group.expects(:commit).in_sequence(create)
       # due to PUP-1967, defaultto false will set the default to nil
-      group.expects(:set_members).with(['user1', 'user2'], nil).in_sequence(create)
+      group.expects(:set_members).with('user1,user2', nil).in_sequence(create)
 
       provider.create
     end
@@ -290,10 +292,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       connection.expects(:Create)
       connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
 
-      expect{ provider.create }.to raise_error(
-                                       Puppet::Error,
-                                       /not able to create\/delete domain groups/
-                                   )
+      expect{ provider.create }.to raise_error(Puppet::Error)
     end
 
     it 'should commit a newly created group' do

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -17,13 +17,13 @@ end
 
     it "[#6009] should handle nested arrays of members" do
       current = ["foo", "bar", "baz"]
-      desired = ["foo", ["quux"], "qorp"]
+      desired = "foo,quux,qorp"
       group   = 'example'
 
       @resource.stubs(:[]).with(:name).returns(group)
       @resource.stubs(:[]).with(:auth_membership).returns(true)
       @provider.instance_variable_set(:@property_value_cache_hash,
-                                      { :members => current })
+                                      { :members => current.join(',') })
 
       %w{bar baz}.each do |del|
         @provider.expects(:execute).once.

data/spec/unit/provider/package/windows/exe_package_spec.rb

@@ -76,7 +76,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     it 'should install using the source' do
       cmd = subject.install_command({:source => source})
 
-      expect(cmd).to eq(['cmd.exe', '/c', 'start', '"puppet-install"', '/w', source])
+      expect(cmd).to eq(source)
     end
   end
 
@@ -84,7 +84,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     ['C:\uninstall.exe', 'C:\Program Files\uninstall.exe'].each do |exe|
       it "should quote #{exe}" do
         expect(subject.new(name, version, exe).uninstall_command).to eq(
-          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', "\"#{exe}\""]
+          "\"#{exe}\""
         )
       end
     end
@@ -92,7 +92,7 @@ describe Puppet::Provider::Package::Windows::ExePackage do
     ['"C:\Program Files\uninstall.exe"', '"C:\Program Files (x86)\Git\unins000.exe" /SILENT"'].each do |exe|
       it "should not quote #{exe}" do
         expect(subject.new(name, version, exe).uninstall_command).to eq(
-          ['cmd.exe', '/c', 'start', '"puppet-uninstall"', '/w', exe]
+          exe
         )
       end
     end

data/spec/unit/provider/package/windows_spec.rb

@@ -1,12 +1,12 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-describe Puppet::Type.type(:package).provider(:windows) do
+describe Puppet::Type.type(:package).provider(:windows), :if => Puppet.features.microsoft_windows? do
   let (:name)        { 'mysql-5.1.58-win-x64' }
-  let (:source)      { 'E:\mysql-5.1.58-win-x64.msi' }
+  let (:source)      { 'E:\Rando\Directory\mysql-5.1.58-win-x64.msi' }
   let (:resource)    {  Puppet::Type.type(:package).new(:name => name, :provider => :windows, :source => source) }
   let (:provider)    { resource.provider }
-  let (:execute_options) do {:failonfail => false, :combine => true} end
+  let (:execute_options) do {:failonfail => false, :combine => true, :suppress_window => true} end
 
   before :each do
     # make sure we never try to execute anything
@@ -86,7 +86,7 @@ describe Puppet::Type.type(:package).provider(:windows) do
   context '#install' do
     let(:command) { 'blarg.exe /S' }
     let(:klass) { mock('installer', :install_command => ['blarg.exe', '/S'] ) }
-
+    let(:execute_options) do {:failonfail => false, :combine => true, :cwd => 'E:\Rando\Directory', :suppress_window => true} end
     before :each do
       Puppet::Provider::Package::Windows::Package.expects(:installer_class).returns(klass)
     end

data/spec/unit/provider/service/launchd_spec.rb

@@ -343,4 +343,23 @@ describe Puppet::Type.type(:service).provider(:launchd) do
       expect { provider.jobsearch("NOSUCH") }.to raise_error(Puppet::Error)
     end
   end
+
+  describe "read_overrides" do
+    before do
+      Kernel.stubs(:sleep)
+    end
+    it "should read overrides" do
+      provider.expects(:read_plist).once.returns({})
+      expect(provider.read_overrides).to eq({})
+    end
+    it "should retry if read_plist fails" do
+      provider.expects(:read_plist).once.returns({})
+      provider.expects(:read_plist).once.returns(nil)
+      expect(provider.read_overrides).to eq({})
+    end
+    it "raises Puppet::Error after 20 attempts" do
+      provider.expects(:read_plist).times(20).returns(nil)
+      expect { provider.read_overrides }.to raise_error(Puppet::Error)
+    end
+ end
 end

data/spec/unit/provider/service/windows_spec.rb

@@ -13,55 +13,46 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
   let(:provider) { resource.provider }
   let(:config)   { Struct::ServiceConfigInfo.new }
   let(:status)   { Struct::ServiceStatus.new }
+  let(:service_util) { Puppet::Util::Windows::Service }
+  let(:service_handle) { mock() }
 
   before :each do
     # make sure we never actually execute anything (there are two execute methods)
     provider.class.expects(:execute).never
     provider.expects(:execute).never
 
-    Win32::Service.stubs(:config_info).with(name).returns(config)
-    Win32::Service.stubs(:status).with(name).returns(status)
+    service_util.stubs(:exists?).with(resource[:name]).returns(true)
   end
 
   describe ".instances" do
     it "should enumerate all services" do
-      list_of_services = ['snmptrap', 'svchost', 'sshd'].map { |s| stub('service', :service_name => s) }
-      Win32::Service.expects(:services).returns(list_of_services)
+      list_of_services = {'snmptrap' => {}, 'svchost' => {}, 'sshd' => {}}
+      service_util.expects(:services).returns(list_of_services)
 
       expect(described_class.instances.map(&:name)).to match_array(['snmptrap', 'svchost', 'sshd'])
     end
   end
 
   describe "#start" do
-    before :each do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_AUTO_START)
+    before(:each) do
+      provider.stubs(:status).returns(:stopped)
     end
 
-    it "should start the service" do
-      provider.expects(:net).with(:start, name)
-
+    it "should resume a paused service" do
+      provider.stubs(:status).returns(:paused)
+      service_util.expects(:resume).with(name)
       provider.start
     end
 
-    it "should raise an error if the start command fails" do
-      provider.expects(:net).with(:start, name).raises(Puppet::ExecutionFailure, "The service name is invalid.")
-
-      expect {
-        provider.start
-      }.to raise_error(Puppet::Error, /Cannot start #{name}, error was: The service name is invalid./)
-    end
-
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.start
-      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
+    it "should start the service" do
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_AUTO_START)
+      service_util.expects(:start).with(name)
+      provider.start
     end
 
-    describe "when the service is disabled" do
+    context "when the service is disabled" do
       before :each do
-        config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
+        service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       end
 
       it "should refuse to start if not managing enable" do
@@ -70,18 +61,16 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
       it "should enable if managing enable and enable is true" do
         resource[:enable] = :true
-
-        provider.expects(:net).with(:start, name)
-        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+        service_util.expects(:start).with(name)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
 
         provider.start
       end
 
       it "should manual start if managing enable and enable is false" do
         resource[:enable] = :false
-
-        provider.expects(:net).with(:start, name)
-        Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+        service_util.expects(:start).with(name)
+        service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
 
         provider.start
       end
@@ -90,44 +79,50 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#stop" do
     it "should stop a running service" do
-      provider.expects(:net).with(:stop, name)
+      service_util.expects(:stop).with(name)
 
       provider.stop
     end
+  end
 
-    it "should raise an error if the stop command fails" do
-      provider.expects(:net).with(:stop, name).raises(Puppet::ExecutionFailure, 'The service name is invalid.')
+  describe "#status" do
+    it "should report a nonexistent service as stopped" do
+      service_util.stubs(:exists?).with(resource[:name]).returns(false)
 
-      expect {
-        provider.stop
-      }.to raise_error(Puppet::Error, /Cannot stop #{name}, error was: The service name is invalid./)
+      expect(provider.status).to eql(:stopped)
     end
-  end
 
-  describe "#status" do
-    ['stopped', 'paused', 'stop pending', 'pause pending'].each do |state|
-      it "should report a #{state} service as stopped" do
-        status.current_state = state
+    [
+      :SERVICE_PAUSED,
+      :SERVICE_PAUSE_PENDING
+    ].each do |state|
+      it "should report a #{state} service as paused" do
+        service_util.expects(:service_state).with(name).returns(state)
+        expect(provider.status).to eq(:paused)
+      end
+    end
 
+    [
+      :SERVICE_STOPPED,
+      :SERVICE_STOP_PENDING
+    ].each do |state|
+      it "should report a #{state} service as stopped" do
+        service_util.expects(:service_state).with(name).returns(state)
         expect(provider.status).to eq(:stopped)
       end
     end
 
-    ["running", "continue pending", "start pending" ].each do |state|
+    [
+      :SERVICE_RUNNING,
+      :SERVICE_CONTINUE_PENDING,
+      :SERVICE_START_PENDING,
+    ].each do |state|
       it "should report a #{state} service as running" do
-        status.current_state = state
+        service_util.expects(:service_state).with(name).returns(state)
 
         expect(provider.status).to eq(:running)
       end
     end
-
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:status).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.status
-      }.to raise_error(Puppet::Error, /Cannot get status of #{name}/)
-    end
   end
 
   describe "#restart" do
@@ -150,34 +145,32 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
   end
 
   describe "#enabled?" do
-    it "should report a service with a startup type of manual as manual" do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DEMAND_START)
+    it "should report a nonexistent service as false" do
+      service_util.stubs(:exists?).with(resource[:name]).returns(false)
 
+      expect(provider.enabled?).to eql(:false)
+    end
+
+    it "should report a service with a startup type of manual as manual" do
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DEMAND_START)
       expect(provider.enabled?).to eq(:manual)
     end
 
     it "should report a service with a startup type of disabled as false" do
-      config.start_type = Win32::Service.get_start_type(Win32::Service::SERVICE_DISABLED)
-
+      service_util.expects(:service_start_type).with(name).returns(:SERVICE_DISABLED)
       expect(provider.enabled?).to eq(:false)
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:config_info).with(name).raises(SystemCallError, 'OpenService')
-
-      expect {
-        provider.enabled?
-      }.to raise_error(Puppet::Error, /Cannot get start type for #{name}/)
-    end
-
     # 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?
-      [Win32::Service::SERVICE_AUTO_START, Win32::Service::SERVICE_BOOT_START, Win32::Service::SERVICE_SYSTEM_START].each do |start_type_const|
-        start_type = Win32::Service.get_start_type(start_type_const)
+      [
+        :SERVICE_AUTO_START,
+        :SERVICE_BOOT_START,
+        :SERVICE_SYSTEM_START
+      ].each do |start_type|
         it "should report a service with a startup type of '#{start_type}' as true" do
-          config.start_type = start_type
-
+          service_util.expects(:service_start_type).with(name).returns(start_type)
           expect(provider.enabled?).to eq(:true)
         end
       end
@@ -186,12 +179,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#enable" do
     it "should set service start type to Service_Auto_Start when enabled" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_AUTO_START).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START)
       provider.enable
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_AUTO_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.enable
@@ -201,12 +194,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#disable" do
     it "should set service start type to Service_Disabled when disabled" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DISABLED).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED)
       provider.disable
-     end
+    end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DISABLED).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.disable
@@ -216,12 +209,12 @@ describe Puppet::Type.type(:service).provider(:windows), :if => Puppet.features.
 
   describe "#manual_start" do
     it "should set service start type to Service_Demand_Start (manual) when manual" do
-      Win32::Service.expects(:configure).with('service_name' => name, 'start_type' => Win32::Service::SERVICE_DEMAND_START).returns(Win32::Service)
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START)
       provider.manual_start
     end
 
-    it "raises an error if the service doesn't exist" do
-      Win32::Service.expects(:configure).with(has_entry('service_name' => name)).raises(SystemCallError, 'OpenService')
+    it "raises an error if set_startup_mode fails" do
+      service_util.expects(:set_startup_mode).with(name, :SERVICE_DEMAND_START).raises(Puppet::Error.new('foobar'))
 
       expect {
         provider.manual_start