puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,59 +1,67 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the OpenWrt service Provider
+#
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.posix? do
+describe 'Puppet::Type::Service::Provider::Openwrt',
+    :if => Puppet.features.posix? && !Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:openwrt) }
+
   let(:resource) do
-    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 = stub 'resource'
+    resource.stubs(:[]).returns(nil)
+    resource.stubs(:[]).with(:name).returns "myservice"
+    resource.stubs(:[]).with(:path).returns ["/etc/init.d"]
 
     resource
   end
 
   let(:provider) do
-    provider = described_class.new
-    allow(provider).to receive(:get).with(:hasstatus).and_return(false)
+    provider = provider_class.new
+    provider.stubs(:get).with(:hasstatus).returns false
 
     provider
   end
 
+
   before :each do
-    allow(resource).to receive(:provider).and_return(provider)
+    resource.stubs(:provider).returns 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)
+    FileTest.stubs(:file?).with('/etc/rc.common').returns true
+    FileTest.stubs(:executable?).with('/etc/rc.common').returns true
 
     # All OpenWrt tests operate on the init script directly. It must exist.
-    allow(File).to receive(:directory?).with('/etc/init.d').and_return(true)
+    File.stubs(:directory?).with('/etc/init.d').returns true
 
-    allow(Puppet::FileSystem).to receive(:exist?).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)
+    Puppet::FileSystem.stubs(:exist?).with('/etc/init.d/myservice').returns true
+    FileTest.stubs(:file?).with('/etc/init.d/myservice').returns true
+    FileTest.stubs(:executable?).with('/etc/init.d/myservice').returns true
   end
 
   operatingsystem = 'openwrt'
   it "should be the default provider on #{operatingsystem}" do
-    expect(Facter).to receive(:value).with(:operatingsystem).and_return(operatingsystem)
-    expect(described_class.default?).to be_truthy
+    Facter.expects(:value).with(:operatingsystem).returns(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' ]}
 
     before :each do
-      allow(Dir).to receive(:entries).and_return(services)
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      Dir.stubs(:entries).returns services
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:executable?).returns(true)
     end
-
     it "should return instances for all services" do
       services.each do |inst|
-        expect(described_class).to receive(:new).with(hash_including(name: inst, path: '/etc/init.d')).and_return("#{inst}_instance")
+        provider_class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
       end
       results = services.collect {|x| "#{x}_instance"}
-      expect(described_class.instances).to eq(results)
+      expect(provider_class.instances).to eq(results)
     end
   end
 
@@ -73,17 +81,17 @@ describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.
     it "should have a #{method} method" do
       expect(provider).to respond_to(method)
     end
-
     describe "when running #{method}" do
+
       it "should use any provided explicit command" do
-        allow(resource).to receive(:[]).with(method).and_return("/user/specified/command")
-        expect(provider).to receive(:execute).with(["/user/specified/command"], any_args)
+        resource.stubs(:[]).with(method).returns "/user/specified/command"
+        provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
         provider.send(method)
       end
 
       it "should execute the init script with #{method} when no explicit command is provided" do
-        allow(resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
-        expect(provider).to receive(:execute).with(['/etc/init.d/myservice', method ], any_args)
+        resource.stubs(:[]).with("has#{method}".intern).returns :true
+        provider.expects(:execute).with { |command, *args| command ==  ['/etc/init.d/myservice', method ]}
         provider.send(method)
       end
     end
@@ -91,13 +99,13 @@ describe Puppet::Type.type(:service).provider(:openwrt), :if => Puppet.features.
 
   describe "when checking status" do
     it "should consider the service :running if it has a pid" do
-      expect(provider).to receive(:getpid).and_return("1234")
+      provider.expects(:getpid).returns "1234"
       expect(provider.status).to eq(:running)
     end
-
     it "should consider the service :stopped if it doesn't have a pid" do
-      expect(provider).to receive(:getpid).and_return(nil)
+      provider.expects(:getpid).returns nil
       expect(provider.status).to eq(:stopped)
     end
   end
+
 end

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

@@ -1,36 +1,41 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:rcng), :unless => Puppet.features.microsoft_windows? do
+describe 'Puppet::Type::Service::Provider::Rcng',
+    :unless => Puppet::Util::Platform.windows? || Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:rcng) }
+
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(described_class)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:netbsd)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('NetBSD')
-    allow(described_class).to receive(:defpath).and_return('/etc/rc.d')
-    @provider = subject()
-    allow(@provider).to receive(:initscript)
+    Puppet::Type.type(:service).stubs(:defaultprovider).returns provider_class
+    Facter.stubs(:value).with(:operatingsystem).returns :netbsd
+    Facter.stubs(:value).with(:osfamily).returns 'NetBSD'
+    provider_class.stubs(:defpath).returns('/etc/rc.d')
+    @provider = provider_class.new
+    @provider.stubs(:initscript)
   end
 
-  context "#enable" do
+  describe "#enable" do
     it "should have an enable method" do
       expect(@provider).to respond_to(:enable)
     end
 
     it "should set the proper contents to enable" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
-      fh = double('fh')
-      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
-      expect(fh).to receive(:puts).with("sshd=${sshd:=YES}\n")
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      fh = stub 'fh'
+      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
+      fh.expects(:puts).with("sshd=${sshd:=YES}\n")
       provider.enable
     end
 
     it "should set the proper contents to enable when disabled" do
-      provider = described_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
-      allow(File).to receive(:read).with('/etc/rc.conf.d/sshd').and_return("sshd_enable=\"NO\"\n")
-      fh = double('fh')
-      expect(Puppet::Util).to receive(:replace_file).with('/etc/rc.conf.d/sshd', 0644).and_yield(fh)
-      expect(fh).to receive(:puts).with("sshd=${sshd:=YES}\n")
+      provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
+      fh = stub 'fh'
+      Puppet::Util.expects(:replace_file).with('/etc/rc.conf.d/sshd', 0644).yields(fh)
+      fh.expects(:puts).with("sshd=${sshd:=YES}\n")
       provider.enable
     end
   end

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

@@ -1,71 +1,76 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the RedHat service Provider
+#
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.posix? do
+describe 'Puppet::Type::Service::Provider::Redhat',
+    :if => Puppet.features.posix? && !Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:redhat) }
+
   before :each do
     @class = Puppet::Type.type(:service).provider(:redhat)
-    @resource = double('resource')
-    allow(@resource).to receive(:[]).and_return(nil)
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    @provider = subject()
-    allow(@resource).to receive(:provider).and_return(@provider)
+    @resource = stub 'resource'
+    @resource.stubs(:[]).returns(nil)
+    @resource.stubs(:[]).with(:name).returns "myservice"
+    @provider = provider_class.new
+    @resource.stubs(:provider).returns @provider
     @provider.resource = @resource
-    allow(@provider).to receive(:get).with(:hasstatus).and_return(false)
-    allow(FileTest).to receive(:file?).with('/sbin/service').and_return(true)
-    allow(FileTest).to receive(:executable?).with('/sbin/service').and_return(true)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return('CentOS')
-    allow(Facter).to receive(:value).with(:osfamily).and_return('RedHat')
+    @provider.stubs(:get).with(:hasstatus).returns false
+    FileTest.stubs(:file?).with('/sbin/service').returns true
+    FileTest.stubs(:executable?).with('/sbin/service').returns true
+    Facter.stubs(:value).with(:operatingsystem).returns('CentOS')
+    Facter.stubs(:value).with(:osfamily).returns 'RedHat'
   end
 
   osfamilies = [ 'RedHat' ]
 
   osfamilies.each do |osfamily|
     it "should be the default provider on #{osfamily}" do
-      expect(Facter).to receive(:value).with(:osfamily).and_return(osfamily)
-      expect(described_class.default?).to be_truthy
+      Facter.expects(:value).with(:osfamily).returns(osfamily)
+      expect(provider_class.default?).to be_truthy
     end
   end
 
   it "should be the default provider on sles11" do
-    allow(Facter).to receive(:value).with(:osfamily).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:suse)
-    allow(Facter).to receive(:value).with(:operatingsystemmajrelease).and_return("11")
-    expect(described_class.default?).to be_truthy
+    Facter.stubs(:value).with(:osfamily).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystem).returns(:suse)
+    Facter.stubs(:value).with(:operatingsystemmajrelease).returns("11")
+    expect(provider_class.default?).to be_truthy
   end
 
   # test self.instances
-  context "when getting all service instances" do
+  describe "when getting all service instances" do
     before :each do
       @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(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:executable?).and_return(true)
+      Dir.stubs(:entries).returns @services
+      FileTest.stubs(:directory?).returns(true)
+      FileTest.stubs(:executable?).returns(true)
     end
-
     it "should return instances for all services" do
       (@services-@not_services).each do |inst|
-        expect(@class).to receive(:new).with(hash_including(name: inst, path: '/etc/init.d')).and_return("#{inst}_instance")
+        @class.expects(:new).with{|hash| hash[:name] == inst && hash[:path] == '/etc/init.d'}.returns("#{inst}_instance")
       end
       results = (@services-@not_services).collect {|x| "#{x}_instance"}
       expect(@class.instances).to eq(results)
     end
-
     it "should call service status when initialized from provider" do
-      allow(@resource).to receive(:[]).with(:status).and_return(nil)
-      allow(@provider).to receive(:get).with(:hasstatus).and_return(true)
-      expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', 'status'], any_args)
+      @resource.stubs(:[]).with(:status).returns nil
+      @provider.stubs(:get).with(:hasstatus).returns true
+      @provider.expects(:execute).with{|command, *args| command == ['/sbin/service', 'myservice', 'status']}
       @provider.send(:status)
     end
   end
 
   it "should use '--add' and 'on' when calling enable" do
-    expect(described_class).to receive(:chkconfig).with("--add", @resource[:name])
-    expect(described_class).to receive(:chkconfig).with(@resource[:name], :on)
+    provider_class.expects(:chkconfig).with("--add", @resource[:name])
+    provider_class.expects(:chkconfig).with(@resource[:name], :on)
     @provider.enable
   end
 
   it "(#15797) should explicitly turn off the service in all run levels" do
-    expect(described_class).to receive(:chkconfig).with("--level", "0123456", @resource[:name], :off)
+    provider_class.expects(:chkconfig).with("--level", "0123456", @resource[:name], :off)
     @provider.disable
   end
 
@@ -73,28 +78,28 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
     expect(@provider).to respond_to(:enabled?)
   end
 
-  context "when checking enabled? on Suse" do
+  describe "when checking enabled? on Suse" do
     before :each do
-      expect(Facter).to receive(:value).with(:osfamily).and_return('Suse')
+      Facter.expects(:value).with(:osfamily).returns 'Suse'
     end
 
     it "should check for on" do
-      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  on")
+      provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  on"
       expect(@provider.enabled?).to eq(:true)
     end
 
     it "should check for B" do
-      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  B")
+      provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  B"
       expect(@provider.enabled?).to eq(:true)
     end
 
     it "should check for off" do
-      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}  off")
+      provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}  off"
       expect(@provider.enabled?).to eq(:false)
     end
 
     it "should check for unknown service" do
-      allow(described_class).to receive(:chkconfig).with(@resource[:name]).and_return("#{@resource[:name]}: unknown service")
+      provider_class.stubs(:chkconfig).with(@resource[:name]).returns "#{@resource[:name]}: unknown service"
       expect(@provider.enabled?).to eq(:false)
     end
   end
@@ -111,65 +116,60 @@ describe Puppet::Type.type(:service).provider(:redhat), :if => Puppet.features.p
     it "should have a #{method} method" do
       expect(@provider).to respond_to(method)
     end
-
     describe "when running #{method}" do
+
       it "should use any provided explicit command" do
-        allow(@resource).to receive(:[]).with(method).and_return("/user/specified/command")
-        expect(@provider).to receive(:execute).with(["/user/specified/command"], any_args)
+        @resource.stubs(:[]).with(method).returns "/user/specified/command"
+        @provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
         @provider.send(method)
       end
 
       it "should execute the service script with #{method} when no explicit command is provided" do
-        allow(@resource).to receive(:[]).with("has#{method}".intern).and_return(:true)
-        expect(@provider).to receive(:execute).with(['/sbin/service', 'myservice', method.to_s], any_args)
+        @resource.stubs(:[]).with("has#{method}".intern).returns :true
+        @provider.expects(:execute).with { |command, *args| command ==  ['/sbin/service', 'myservice', method.to_s]}
         @provider.send(method)
       end
     end
   end
 
-  context "when checking status" do
-    context "when hasstatus is :true" do
+  describe "when checking status" do
+    describe "when hasstatus is :true" do
       before :each do
-        allow(@resource).to receive(:[]).with(:hasstatus).and_return(:true)
+        @resource.stubs(:[]).with(:hasstatus).returns :true
       end
-
       it "should execute the service script with fail_on_failure false" do
-        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+        @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
         @provider.status
       end
-
       it "should consider the process running if the command returns 0" do
-        expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-        allow($CHILD_STATUS).to receive(:exitstatus).and_return(0)
+        @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+        $CHILD_STATUS.stubs(:exitstatus).returns(0)
         expect(@provider.status).to eq(:running)
       end
-
       [-10,-1,1,10].each { |ec|
         it "should consider the process stopped if the command returns something non-0" do
-          expect(@provider).to receive(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
-          allow($CHILD_STATUS).to receive(:exitstatus).and_return(ec)
+          @provider.expects(:texecute).with(:status, ['/sbin/service', 'myservice', 'status'], false)
+          $CHILD_STATUS.stubs(:exitstatus).returns(ec)
           expect(@provider.status).to eq(:stopped)
         end
       }
     end
-
-    context "when hasstatus is not :true" do
+    describe "when hasstatus is not :true" do
       it "should consider the service :running if it has a pid" do
-        expect(@provider).to receive(:getpid).and_return("1234")
+        @provider.expects(:getpid).returns "1234"
         expect(@provider.status).to eq(:running)
       end
-
       it "should consider the service :stopped if it doesn't have a pid" do
-        expect(@provider).to receive(:getpid).and_return(nil)
+        @provider.expects(:getpid).returns nil
         expect(@provider.status).to eq(:stopped)
       end
     end
   end
 
-  context "when restarting and hasrestart is not :true" do
+  describe "when restarting and hasrestart is not :true" do
     it "should stop and restart the process with the server script" do
-      expect(@provider).to receive(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
-      expect(@provider).to receive(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
+      @provider.expects(:texecute).with(:stop,  ['/sbin/service', 'myservice', 'stop'],  true)
+      @provider.expects(:texecute).with(:start, ['/sbin/service', 'myservice', 'start'], true)
       @provider.restart
     end
   end

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

@@ -1,29 +1,37 @@
+#! /usr/bin/env ruby
+#
+# Unit testing for the Runit service Provider
+#
+# author Brice Figureau
+#
 require 'spec_helper'
 
-describe Puppet::Type.type(:service).provider(:runit) do
+describe 'Puppet::Type::Service::Provider::Runit', unless: Puppet::Util::Platform.jruby? do
+  let(:provider_class) { Puppet::Type.type(:service).provider(:runit) }
+
   before(:each) do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
-    @provider = subject()
+    @provider = provider_class.new
     @servicedir = "/etc/service"
     @provider.servicedir=@servicedir
     @daemondir = "/etc/sv"
     @provider.class.defpath=@daemondir
 
     # A catch all; no parameters set
-    allow(@resource).to receive(:[]).and_return(nil)
+    @resource.stubs(:[]).returns(nil)
 
     # But set name, source and path (because we won't run
     # the thing that will fetch the resource path from the provider)
-    allow(@resource).to receive(:[]).with(:name).and_return("myservice")
-    allow(@resource).to receive(:[]).with(:ensure).and_return(:enabled)
-    allow(@resource).to receive(:[]).with(:path).and_return(@daemondir)
-    allow(@resource).to receive(:ref).and_return("Service[myservice]")
+    @resource.stubs(:[]).with(:name).returns "myservice"
+    @resource.stubs(:[]).with(:ensure).returns :enabled
+    @resource.stubs(:[]).with(:path).returns @daemondir
+    @resource.stubs(:ref).returns "Service[myservice]"
 
-    allow(@provider).to receive(:sv)
+    @provider.stubs(:sv)
 
-    allow(@provider).to receive(:resource).and_return(@resource)
+    @provider.stubs(:resource).returns @resource
   end
 
   it "should have a restart method" do
@@ -54,108 +62,83 @@ describe Puppet::Type.type(:service).provider(:runit) do
     expect(@provider).to respond_to(:disable)
   end
 
-  context "when starting" do
+  describe "when starting" do
     it "should enable the service if it is not enabled" do
-      allow(@provider).to receive(:sv)
+      @provider.stubs(:sv)
 
-      expect(@provider).to receive(:enabled?).and_return(:false)
-      expect(@provider).to receive(:enable)
-      allow(@provider).to receive(:sleep)
+      @provider.expects(:enabled?).returns :false
+      @provider.expects(:enable)
+      @provider.stubs(:sleep)
 
       @provider.start
     end
 
     it "should execute external command 'sv start /etc/service/myservice'" do
-      allow(@provider).to receive(:enabled?).and_return(:true)
-      expect(@provider).to receive(:sv).with("start", "/etc/service/myservice")
+      @provider.stubs(:enabled?).returns :true
+      @provider.expects(:sv).with("start", "/etc/service/myservice")
       @provider.start
     end
   end
 
-  context "when stopping" do
+  describe "when stopping" do
     it "should execute external command 'sv stop /etc/service/myservice'" do
-      expect(@provider).to receive(:sv).with("stop", "/etc/service/myservice")
+      @provider.expects(:sv).with("stop", "/etc/service/myservice")
       @provider.stop
     end
   end
 
-  context "when restarting" do
+  describe "when restarting" do
     it "should call 'sv restart /etc/service/myservice'" do
-      expect(@provider).to receive(:sv).with("restart","/etc/service/myservice")
+      @provider.expects(:sv).with("restart","/etc/service/myservice")
       @provider.restart
     end
   end
 
-  context "when enabling" do
+  describe "when enabling" do
     it "should create a symlink between daemon dir and service dir", :if => Puppet.features.manages_symlinks? do
       daemon_path = File.join(@daemondir,"myservice")
       service_path = File.join(@servicedir,"myservice")
-      expect(Puppet::FileSystem).to receive(:symlink?).with(service_path).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink).with(daemon_path, File.join(@servicedir,"myservice")).and_return(0)
+      Puppet::FileSystem.expects(:symlink?).with(service_path).returns(false)
+      Puppet::FileSystem.expects(:symlink).with(daemon_path, File.join(@servicedir,"myservice")).returns(0)
       @provider.enable
     end
   end
 
-  context "when disabling" do
+  describe "when disabling" do
     it "should remove the '/etc/service/myservice' symlink" do
       path = File.join(@servicedir,"myservice")
-      allow(FileTest).to receive(:directory?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
-      expect(Puppet::FileSystem).to receive(:unlink).with(path).and_return(0)
+#      mocked_file = mock(path, :symlink? => true)
+      FileTest.stubs(:directory?).returns(false)
+      Puppet::FileSystem.expects(:symlink?).with(path).returns(true) # mocked_file)
+      Puppet::FileSystem.expects(:unlink).with(path).returns(0)
       @provider.disable
     end
   end
 
-  context "when checking status" do
+  describe "when checking status" do
     it "should call the external command 'sv status /etc/sv/myservice'" do
-      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice"))
+      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice"))
       @provider.status
     end
   end
 
-  context "when checking status" do
+  describe "when checking status" do
     it "and sv status fails, properly raise a Puppet::Error" do
-      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_raise(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
+      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).raises(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
       expect { @provider.status }.to raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: fail: /etc/sv/myservice: file not found')
     end
-
     it "and sv status returns up, then return :running" do
-      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("run: /etc/sv/myservice: (pid 9029) 6s")
+      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("run: /etc/sv/myservice: (pid 9029) 6s")
       expect(@provider.status).to eq(:running)
     end
-
     it "and sv status returns not running, then return :stopped" do
-      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("fail: /etc/sv/myservice: runsv not running")
+      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("fail: /etc/sv/myservice: runsv not running")
       expect(@provider.status).to eq(:stopped)
     end
-
     it "and sv status returns a warning, then return :stopped" do
-      expect(@provider).to receive(:sv).with('status',File.join(@daemondir,"myservice")).and_return("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
+      @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
       expect(@provider.status).to eq(:stopped)
     end
   end
 
-  context '.instances' do
-    before do
-      allow(described_class).to receive(:defpath).and_return(path)
-    end
-
-    context 'when defpath is nil' do
-      let(:path) { nil }
-
-      it 'returns info message' do
-        expect(Puppet).to receive(:info).with(/runit is unsuitable because service directory is nil/)
-        described_class.instances
-      end
-    end
-
-    context 'when defpath does not exist' do
-      let(:path) { '/inexistent_path' }
-
-      it 'returns notice about missing path' do
-        expect(Puppet).to receive(:notice).with(/Service path #{path} does not exist/)
-        described_class.instances
-      end
-    end
-  end
 end