puppet 6.29.0-x64-mingw32 → 7.0.0-x64-mingw32

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

@@ -2,56 +2,61 @@ require 'spec_helper'
 
 describe 'Puppet::Type::Service::Provider::Openwrt',
          unless: Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
-
   let(:provider_class) { Puppet::Type.type(:service).provider(:openwrt) }
 
   let(:resource) do
-    Puppet::Type.type(:service).new(
-      :name       => 'myservice',
-      :path       => '/etc/init.d',
-      :hasrestart => true,
-    )
+    resource = double('resource')
+    allow(resource).to receive(:[]).and_return(nil)
+    allow(resource).to receive(:[]).with(:name).and_return("myservice")
+    allow(resource).to receive(:[]).with(:path).and_return(["/etc/init.d"])
+
+    resource
   end
 
   let(:provider) do
     provider = provider_class.new
-    provider.resource = resource
+    allow(provider).to receive(:get).with(:hasstatus).and_return(false)
+
     provider
   end
 
   before :each do
-    resource.provider = provider
+    allow(resource).to receive(:provider).and_return(provider)
+    provider.resource = resource
+
+    allow(FileTest).to receive(:file?).with('/etc/rc.common').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/rc.common').and_return(true)
 
     # All OpenWrt tests operate on the init script directly. It must exist.
-    allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-    allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
+    allow(File).to receive(:directory?).and_call_original
+    allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
 
     allow(Puppet::FileSystem).to receive(:exist?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:file?).and_call_original
-    allow(Puppet::FileSystem).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
-    allow(Puppet::FileSystem).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:file?).with('/etc/init.d/myservice').and_return(true)
+    allow(FileTest).to receive(:executable?).with('/etc/init.d/myservice').and_return(true)
   end
 
-  it "should be the default provider on 'openwrt'" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return('openwrt')
+  operatingsystem = 'openwrt'
+  it "should be the default provider on #{operatingsystem}" do
+    expect(Facter).to receive(:value).with(:operatingsystem).and_return(operatingsystem)
     expect(provider_class.default?).to be_truthy
   end
 
   # test self.instances
   describe "when getting all service instances" do
-    let(:services) { ['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ] }
+    let(:services) {['dnsmasq', 'dropbear', 'firewall', 'led', 'puppet', 'uhttpd' ]}
 
     before :each do
-      allow(Dir).to receive(:entries).and_call_original
-      allow(Dir).to receive(:entries).with('/etc/init.d').and_return(services)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
+      allow(Dir).to receive(:entries).and_return(services)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do
       services.each do |inst|
         expect(provider_class).to receive(:new).with(hash_including(:name => inst, :path => '/etc/init.d')).and_return("#{inst}_instance")
       end
-      results = services.collect { |x| "#{x}_instance"}
+      results = services.collect {|x| "#{x}_instance"}
       expect(provider_class.instances).to eq(results)
     end
   end
@@ -75,13 +80,14 @@ describe 'Puppet::Type::Service::Provider::Openwrt',
 
     describe "when running #{method}" do
       it "should use any provided explicit command" do
-        resource[method] = '/user/specified/command'
-        expect(provider).to receive(:execute).with(['/user/specified/command'], any_args)
+        allow(resource).to receive(:[]).with(method).and_return("/user/specified/command")
+        expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
         provider.send(method)
       end
 
       it "should execute the init script with #{method} when no explicit command is provided" do
-        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method], any_args)
+        allow(resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
+        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method ], any_args)
         provider.send(method)
       end
     end

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

@@ -50,9 +50,8 @@ describe 'Puppet::Type::Service::Provider::Redhat',
       @services = ['one', 'two', 'three', 'four', 'kudzu', 'functions', 'halt', 'killall', 'single', 'linuxconf', 'boot', 'reboot']
       @not_services = ['functions', 'halt', 'killall', 'single', 'linuxconf', 'reboot', 'boot']
       allow(Dir).to receive(:entries).and_return(@services)
-      allow(Puppet::FileSystem).to receive(:directory?).and_call_original
-      allow(Puppet::FileSystem).to receive(:directory?).with('/etc/init.d').and_return(true)
-      allow(Puppet::FileSystem).to receive(:executable?).and_return(true)
+      allow(FileTest).to receive(:directory?).and_return(true)
+      allow(FileTest).to receive(:executable?).and_return(true)
     end
 
     it "should return instances for all services" do