puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/provider/parsedfile_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 
@@ -30,60 +31,60 @@ describe Puppet::Provider::ParsedFile do
 
   describe "when generating a list of instances" do
     it "should return an instance for each record parsed from all of the registered targets" do
-      expect(provider).to receive(:targets).and_return(%w{/one /two})
-      allow(provider).to receive(:skip_record?).and_return(false)
+      provider.expects(:targets).returns %w{/one /two}
+      provider.stubs(:skip_record?).returns false
       one = [:uno1, :uno2]
       two = [:dos1, :dos2]
-      expect(provider).to receive(:prefetch_target).with("/one").and_return(one)
-      expect(provider).to receive(:prefetch_target).with("/two").and_return(two)
+      provider.expects(:prefetch_target).with("/one").returns one
+      provider.expects(:prefetch_target).with("/two").returns two
 
       results = []
       (one + two).each do |inst|
         results << inst.to_s + "_instance"
-        expect(provider).to receive(:new).with(inst).and_return(results[-1])
+        provider.expects(:new).with(inst).returns(results[-1])
       end
 
       expect(provider.instances).to eq(results)
     end
 
     it "should ignore target when retrieve fails" do
-      expect(provider).to receive(:targets).and_return(%w{/one /two /three})
-      allow(provider).to receive(:skip_record?).and_return(false)
-      expect(provider).to receive(:retrieve).with("/one").and_return([
+      provider.expects(:targets).returns %w{/one /two /three}
+      provider.stubs(:skip_record?).returns false
+      provider.expects(:retrieve).with("/one").returns [
         {:name => 'target1_record1'},
         {:name => 'target1_record2'}
-      ])
-      expect(provider).to receive(:retrieve).with("/two").and_raise(Puppet::Util::FileType::FileReadError, "some error")
-      expect(provider).to receive(:retrieve).with("/three").and_return([
+      ]
+      provider.expects(:retrieve).with("/two").raises Puppet::Util::FileType::FileReadError, "some error"
+      provider.expects(:retrieve).with("/three").returns [
         {:name => 'target3_record1'},
         {:name => 'target3_record2'}
-      ])
-      expect(Puppet).to receive(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
-      expect(provider).to receive(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).and_return('r1')
-      expect(provider).to receive(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).and_return('r2')
-      expect(provider).to receive(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).and_return('r3')
-      expect(provider).to receive(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).and_return('r4')
+      ]
+      Puppet.expects(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
+      provider.expects(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).returns 'r1'
+      provider.expects(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).returns 'r2'
+      provider.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
+      provider.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
 
       expect(provider.instances).to eq(%w{r1 r2 r3 r4})
     end
 
     it "should skip specified records" do
-      expect(provider).to receive(:targets).and_return(%w{/one})
-      expect(provider).to receive(:skip_record?).with(:uno).and_return(false)
-      expect(provider).to receive(:skip_record?).with(:dos).and_return(true)
+      provider.expects(:targets).returns %w{/one}
+      provider.expects(:skip_record?).with(:uno).returns false
+      provider.expects(:skip_record?).with(:dos).returns true
       one = [:uno, :dos]
-      expect(provider).to receive(:prefetch_target).and_return(one)
+      provider.expects(:prefetch_target).returns one
 
-      expect(provider).to receive(:new).with(:uno).and_return("eh")
-      expect(provider).not_to receive(:new).with(:dos)
+      provider.expects(:new).with(:uno).returns "eh"
+      provider.expects(:new).with(:dos).never
 
       provider.instances
     end
   end
 
   describe "when matching resources to existing records" do
-    let(:first_resource) { double(:one, :name => :one) }
-    let(:second_resource) { double(:two, :name => :two) }
+    let(:first_resource) { stub(:one, :name => :one) }
+    let(:second_resource) { stub(:two, :name => :two) }
 
     let(:resources) {{:one => first_resource, :two => second_resource}}
 
@@ -101,41 +102,41 @@ describe Puppet::Provider::ParsedFile do
   describe "when flushing a file's records to disk" do
     before do
       # This way we start with some @records, like we would in real life.
-      allow(provider).to receive(:retrieve).and_return([])
+      provider.stubs(:retrieve).returns []
       provider.default_target = "/foo/bar"
       provider.initvars
       provider.prefetch
 
       @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
-      allow(Puppet::Util::FileType.filetype(:flat)).to receive(:new).with("/my/file").and_return(@filetype)
+      Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file",nil).returns @filetype
 
-      allow(@filetype).to receive(:write)
+      @filetype.stubs(:write)
     end
 
     it "should back up the file being written if the filetype can be backed up" do
-      expect(@filetype).to receive(:backup)
+      @filetype.expects(:backup)
 
       provider.flush_target("/my/file")
     end
 
     it "should not try to back up the file if the filetype cannot be backed up" do
       @filetype = Puppet::Util::FileType.filetype(:ram).new("/my/file")
-      expect(Puppet::Util::FileType.filetype(:flat)).to receive(:new).and_return(@filetype)
+      Puppet::Util::FileType.filetype(:flat).expects(:new).returns @filetype
 
-      allow(@filetype).to receive(:write)
+      @filetype.stubs(:write)
 
       provider.flush_target("/my/file")
     end
 
     it "should not back up the file more than once between calls to 'prefetch'" do
-      expect(@filetype).to receive(:backup).once
+      @filetype.expects(:backup).once
 
       provider.flush_target("/my/file")
       provider.flush_target("/my/file")
     end
 
     it "should back the file up again once the file has been reread" do
-      expect(@filetype).to receive(:backup).twice
+      @filetype.expects(:backup).times(2)
 
       provider.flush_target("/my/file")
       provider.prefetch
@@ -146,19 +147,19 @@ describe Puppet::Provider::ParsedFile do
   describe "when flushing multiple files" do
     describe "and an error is encountered" do
       it "the other file does not fail" do
-        allow(provider).to receive(:backup_target)
+        provider.stubs(:backup_target)
 
         bad_file = 'broken'
         good_file = 'writable'
 
-        bad_writer = double('bad')
-        expect(bad_writer).to receive(:write).and_raise(Exception, "Failed to write to bad file")
+        bad_writer = mock 'bad'
+        bad_writer.expects(:write).raises(Exception, "Failed to write to bad file")
 
-        good_writer = double('good')
-        expect(good_writer).to receive(:write).and_return(nil)
+        good_writer = mock 'good'
+        good_writer.expects(:write).returns(nil)
 
-        allow(provider).to receive(:target_object).with(bad_file).and_return(bad_writer)
-        allow(provider).to receive(:target_object).with(good_file).and_return(good_writer)
+        provider.stubs(:target_object).with(bad_file).returns(bad_writer)
+        provider.stubs(:target_object).with(good_file).returns(good_writer)
 
         bad_resource = parsed_type.new(:name => 'one', :target => bad_file)
         good_resource = parsed_type.new(:name => 'two', :target => good_file)
@@ -189,8 +190,8 @@ describe "A very basic provider based on ParsedFile" do
     example_provider_class.initvars
     example_provider_class.prefetch
     # evade a race between multiple invocations of the header method
-    allow(example_provider_class).to receive(:header).
-      and_return("# HEADER As added by puppet.\n")
+    example_provider_class.stubs(:header).
+      returns("# HEADER As added by puppet.\n")
     example_provider_class
   end
 
@@ -207,7 +208,7 @@ describe "A very basic provider based on ParsedFile" do
     let(:input_records) { provider.parse(input_text) }
 
     before :each do
-      allow(provider).to receive(:native_header_regex).and_return(regex)
+      provider.stubs(:native_header_regex).returns(regex)
     end
 
     it "should move the native header to the top" do
@@ -216,7 +217,7 @@ describe "A very basic provider based on ParsedFile" do
 
     context "and dropping native headers found in input" do
       before :each do
-        allow(provider).to receive(:drop_native_header).and_return(true)
+        provider.stubs(:drop_native_header).returns(true)
       end
 
       it "should not include the native header in the output" do

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'rbconfig'
 require 'fileutils'
@@ -40,7 +41,7 @@ describe "base service provider" do
         return 'started'
       when status_command
         expect(options[:failonfail]).to eq(false)
-        allow($CHILD_STATUS).to receive(:exitstatus) {@running ? 0 : 1}
+        $CHILD_STATUS.expects(:exitstatus).at_least(1).returns(@running ? 0 : 1)
         return @running ? 'running' : 'not running'
       when stop_command
         expect(options[:failonfail]).to eq(true)
@@ -54,7 +55,7 @@ describe "base service provider" do
 
     before :each do
       @running = false
-      expect(executor).to receive(:execute).at_least(:once) { |command, options| execute_command(command, options) }
+      executor.expects(:execute).at_least(1).with { |command, options| execute_command(command, options) }
     end
 
     it "should invoke the start command if not running" do
@@ -100,10 +101,10 @@ describe "base service provider" do
     end
 
     it "retrieves a PID from the process table" do
-      allow(Facter).to receive(:value).with(:operatingsystem).and_return("CentOS")
+      Facter.stubs(:value).with(:operatingsystem).returns("CentOS")
       ps_output = File.binread(my_fixture("ps_ef.mixed_encoding")).force_encoding(Encoding::UTF_8)
 
-      expect(executor).to receive(:execute).with("ps -ef").and_return(ps_output)
+      executor.expects(:execute).with("ps -ef").returns(ps_output)
 
       expect(subject.status).to eq(:running)
     end

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

@@ -5,12 +5,12 @@ describe 'Puppet::Type::Service::Provider::Bsd',
   let(:provider_class) { Puppet::Type.type(:service).provider(:bsd) }
 
   before :each do
-    allow(Puppet::Type.type(:service)).to receive(:defaultprovider).and_return(provider_class)
-    allow(Facter).to receive(:value).with(:operatingsystem).and_return(:netbsd)
-    allow(Facter).to receive(:value).with(:osfamily).and_return('NetBSD')
-    allow(provider_class).to receive(:defpath).and_return('/etc/rc.conf.d')
+    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.conf.d')
     @provider = provider_class.new
-    allow(@provider).to receive(:initscript)
+    @provider.stubs(:initscript)
   end
 
   context "#instances" do
@@ -30,16 +30,16 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should remove a service file to disable" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
-      allow(File).to receive(:delete).with('/etc/rc.conf.d/sshd')
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      File.stubs(:delete).with('/etc/rc.conf.d/sshd')
       provider.disable
     end
 
     it "should not remove a service file if it doesn't exist" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(File).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
-      expect(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
+      File.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      Puppet::FileSystem.expects(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
       provider.disable
     end
   end
@@ -51,20 +51,20 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should set the proper contents to enable" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Dir).to receive(:mkdir).with('/etc/rc.conf.d')
-      fh = double('fh')
-      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
-      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
+      Dir.stubs(:mkdir).with('/etc/rc.conf.d')
+      fh = stub 'fh'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
       provider.enable
     end
 
     it "should set the proper contents to enable when disabled" do
       provider = provider_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')
-      allow(File).to receive(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).and_yield(fh)
-      expect(fh).to receive(:<<).with("sshd_enable=\"YES\"\n")
+      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'
+      File.stubs(:open).with('/etc/rc.conf.d/sshd', File::WRONLY | File::APPEND | File::CREAT, 0644).yields(fh)
+      fh.expects(:<<).with("sshd_enable=\"YES\"\n")
       provider.enable
     end
   end
@@ -76,13 +76,15 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should return false if the service file does not exist" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(false)
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(false)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"NO\"\n")
       expect(provider.enabled?).to eq(:false)
     end
 
     it "should return true if the service file exists" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/rc.conf.d/sshd').and_return(true)
+      Puppet::FileSystem.stubs(:exist?).with('/etc/rc.conf.d/sshd').returns(true)
+      # File.stubs(:read).with('/etc/rc.conf.d/sshd').returns("sshd_enable=\"YES\"\n")
       expect(provider.enabled?).to eq(:true)
     end
   end
@@ -94,14 +96,14 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should use the supplied start command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :start => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.start
     end
 
     it "should start the serviced directly otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestart], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.start
     end
   end
@@ -113,14 +115,14 @@ describe 'Puppet::Type::Service::Provider::Bsd',
 
     it "should use the supplied stop command if specified" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd', :stop => '/bin/foo'))
-      expect(provider).to receive(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:execute).with(['/bin/foo'], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
       provider.stop
     end
 
     it "should stop the serviced directly otherwise" do
       provider = provider_class.new(Puppet::Type.type(:service).new(:name => 'sshd'))
-      expect(provider).to receive(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
-      expect(provider).to receive(:search).with('sshd').and_return('/etc/rc.d/sshd')
+      provider.expects(:execute).with(['/etc/rc.d/sshd', :onestop], :failonfail => true, :override_locale => false, :squelch => false, :combine => true)
+      provider.expects(:search).with('sshd').returns('/etc/rc.d/sshd')
       provider.stop
     end
   end

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

@@ -6,7 +6,7 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   before(:each) do
     # Create a mock resource
-    @resource = double('resource')
+    @resource = stub 'resource'
 
     @provider = provider_class.new
     @servicedir = "/etc/service"
@@ -15,22 +15,22 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
     @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]"
 
     @provider.resource = @resource
 
-    allow(@provider).to receive(:command).with(:svc).and_return("svc")
-    allow(@provider).to receive(:command).with(:svstat).and_return("svstat")
+    @provider.stubs(:command).with(:svc).returns "svc"
+    @provider.stubs(:command).with(:svstat).returns "svstat"
 
-    allow(@provider).to receive(:svc)
-    allow(@provider).to receive(:svstat)
+    @provider.stubs(:svc)
+    @provider.stubs(:svstat)
   end
 
   it "should have a restart method" do
@@ -59,17 +59,17 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   context "when starting" do
     it "should use 'svc' to start the service" do
-      allow(@provider).to receive(:enabled?).and_return(:true)
-      expect(@provider).to receive(:svc).with("-u", "/etc/service/myservice")
+      @provider.stubs(:enabled?).returns :true
+      @provider.expects(:svc).with("-u", "/etc/service/myservice")
 
       @provider.start
     end
 
     it "should enable the service if it is not enabled" do
-      allow(@provider).to receive(:svc)
+      @provider.stubs(:svc)
 
-      expect(@provider).to receive(:enabled?).and_return(:false)
-      expect(@provider).to receive(:enable)
+      @provider.expects(:enabled?).returns :false
+      @provider.expects(:enable)
 
       @provider.start
     end
@@ -77,8 +77,8 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   context "when stopping" do
     it "should use 'svc' to stop the service" do
-      allow(@provider).to receive(:disable)
-      expect(@provider).to receive(:svc).with("-d", "/etc/service/myservice")
+      @provider.stubs(:disable)
+      @provider.expects(:svc).with("-d", "/etc/service/myservice")
 
       @provider.stop
     end
@@ -86,7 +86,7 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   context "when restarting" do
     it "should use 'svc' to restart the service" do
-      expect(@provider).to receive(:svc).with("-t", "/etc/service/myservice")
+      @provider.expects(:svc).with("-t", "/etc/service/myservice")
 
       @provider.restart
     end
@@ -96,8 +96,8 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
     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, service_path).and_return(0)
+      Puppet::FileSystem.expects(:symlink?).with(service_path).returns(false)
+      Puppet::FileSystem.expects(:symlink).with(daemon_path, service_path).returns(0)
 
       @provider.enable
     end
@@ -105,35 +105,35 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   context "when disabling" do
     it "should remove the symlink between daemon dir and service dir" do
-      allow(FileTest).to receive(:directory?).and_return(false)
+      FileTest.stubs(:directory?).returns(false)
       path = File.join(@servicedir,"myservice")
-      expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(true)
-      expect(Puppet::FileSystem).to receive(:unlink).with(path)
-      allow(@provider).to receive(:texecute).and_return("")
+      Puppet::FileSystem.expects(:symlink?).with(path).returns(true)
+      Puppet::FileSystem.expects(:unlink).with(path)
+      @provider.stubs(:texecute).returns("")
       @provider.disable
     end
 
     it "should stop the service" do
-      allow(FileTest).to receive(:directory?).and_return(false)
-      expect(Puppet::FileSystem).to receive(:symlink?).and_return(true)
-      allow(Puppet::FileSystem).to receive(:unlink)
-      expect(@provider).to receive(:stop)
+      FileTest.stubs(:directory?).returns(false)
+      Puppet::FileSystem.expects(:symlink?).returns(true)
+      Puppet::FileSystem.stubs(:unlink)
+      @provider.expects(:stop)
       @provider.disable
     end
   end
 
   context "when checking if the service is enabled?" do
     it "should return true if it is running" do
-      allow(@provider).to receive(:status).and_return(:running)
+      @provider.stubs(:status).returns(:running)
 
       expect(@provider.enabled?).to eq(:true)
     end
 
     [true, false].each do |t|
       it "should return #{t} if the symlink exists" do
-        allow(@provider).to receive(:status).and_return(:stopped)
+        @provider.stubs(:status).returns(:stopped)
         path = File.join(@servicedir,"myservice")
-        expect(Puppet::FileSystem).to receive(:symlink?).with(path).and_return(t)
+        Puppet::FileSystem.expects(:symlink?).with(path).returns(t)
 
         expect(@provider.enabled?).to eq("#{t}".to_sym)
       end
@@ -142,24 +142,24 @@ describe 'Puppet::Type::Service::Provider::Daemontools',
 
   context "when checking status" do
     it "should call the external command 'svstat /etc/service/myservice'" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice"))
+      @provider.expects(:svstat).with(File.join(@servicedir,"myservice"))
       @provider.status
     end
   end
 
   context "when checking status" do
     it "and svstat fails, properly raise a Puppet::Error" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_raise(Puppet::ExecutionFailure, "failure")
+      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).raises(Puppet::ExecutionFailure, "failure")
       expect { @provider.status }.to raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: failure')
     end
 
     it "and svstat returns up, then return :running" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: up (pid 454) 954326 seconds")
+      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: up (pid 454) 954326 seconds")
       expect(@provider.status).to eq(:running)
     end
 
     it "and svstat returns not running, then return :stopped" do
-      expect(@provider).to receive(:svstat).with(File.join(@servicedir,"myservice")).and_return("/etc/service/myservice: supervise not running")
+      @provider.expects(:svstat).with(File.join(@servicedir,"myservice")).returns("/etc/service/myservice: supervise not running")
       expect(@provider.status).to  eq(:stopped)
     end
   end