puppet 3.1.1 → 3.2.0.rc1

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

@@ -11,14 +11,61 @@ describe provider_class do
     cracklib-dicts 0 2.8.9 3.3 x86_64
     basesystem 0 8.0 5.1.1.el5.centos noarch
     chkconfig 0 1.3.30.2 2.el5 x86_64
+    myresource 0 1.2.3.4 5.el4 noarch
     RPM_OUTPUT
   end
 
+  let(:resource) do
+    Puppet::Type.type(:package).new(
+      :name     => 'myresource',
+      :ensure   => :installed
+    )
+  end
+
+  let(:provider) do
+    provider = provider_class.new
+    provider.resource = resource
+    provider
+  end
+
+  let(:rpm_version) { "RPM version 5.0.0\n" }
+
+  before(:each) do
+    Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
+    subject.stubs(:which).with("rpm").returns("/bin/rpm")
+    subject.instance_variable_set("@current_version", nil)
+    Puppet::Type::Package::ProviderRpm.expects(:execute).with(["/bin/rpm", "--version"]).returns(rpm_version).at_most_once
+    Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:failonfail => true, :combine => true, :custom_environment => {}}).returns(rpm_version).at_most_once
+  end
+
   describe "self.instances" do
+    describe "with a modern version of RPM" do
+      it "should include all the modern flags" do
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n'").yields(packages)
+
+        installed_packages = subject.instances
+      end
+    end
+
+    describe "with a version of RPM < 4.1" do
+      let(:rpm_version) { "RPM version 4.0.2\n" }
+      it "should exclude the --nosignature flag" do
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa  --nodigest --qf '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n'").yields(packages)
+
+        installed_packages = subject.instances
+      end
+    end
+
+    describe "with a version of RPM < 4.0.2" do
+      let(:rpm_version) { "RPM version 3.0.5\n" }
+      it "should exclude the --nodigest flag" do
+        Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa   --qf '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n'").yields(packages)
+
+        installed_packages = subject.instances
+      end
+    end
+
     it "returns an array of packages" do
-      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:failonfail => true, :combine => true, :custom_environment => {}}).returns("RPM version 5.x")
-      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
-      subject.stubs(:which).with("rpm").returns("/bin/rpm")
       Puppet::Util::Execution.expects(:execpipe).with("/bin/rpm -qa --nosignature --nodigest --qf '%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n'").yields(packages)
 
       installed_packages = subject.instances
@@ -55,4 +102,103 @@ describe provider_class do
         }
     end
   end
+
+  describe "#install" do
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => 'myresource',
+        :ensure   => :installed,
+        :source   => '/path/to/package'
+      )
+    end
+
+    describe "when not already installed" do
+      it "should only include the '-i' flag" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-i", '/path/to/package'], {:failonfail => true, :combine => true, :custom_environment => {}})
+        provider.install
+      end
+   end
+
+   describe "when an older version is installed" do
+     before(:each) do
+       # Force the provider to think a version of the package is already installed
+       # This is real hacky. I'm sorry.  --jeffweiss 25 Jan 2013
+       provider.instance_variable_get('@property_hash')[:ensure] = '1.2.3.3'
+     end
+
+     it "should include the '-U --oldpackage' flags" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", ["-U", "--oldpackage"], '/path/to/package'], {:failonfail => true, :combine => true, :custom_environment => {}})
+        provider.install
+     end
+   end
+  end
+
+  describe "#uninstall" do
+    let(:resource) do
+      Puppet::Type.type(:package).new(
+        :name     => 'myresource',
+        :ensure   => :installed
+      )
+    end
+
+    describe "on a modern RPM" do
+      before(:each) do 
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q",  "myresource", '--nosignature', '--nodigest', "--qf", "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n"], {:failonfail => true, :combine => true, :custom_environment => {}}).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      end
+
+      let(:rpm_version) { "RPM version 4.10.0\n" }
+
+      it "should include the architecture in the package name" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-e", 'myresource-1.2.3.4-5.el4.noarch'], {:failonfail => true, :combine => true, :custom_environment => {}}).returns('').at_most_once
+        provider.uninstall
+      end
+    end
+
+    describe "on an ancient RPM" do
+      before(:each) do 
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q",  "myresource", '', '', "--qf", "%{NAME} %|EPOCH?{%{EPOCH}}:{0}| %{VERSION} %{RELEASE} %{ARCH}\n"], {:failonfail => true, :combine => true, :custom_environment => {}}).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      end
+
+      let(:rpm_version) { "RPM version 3.0.6\n" }
+
+      it "should exclude the architecture from the package name" do
+        Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-e", 'myresource-1.2.3.4-5.el4'], {:failonfail => true, :combine => true, :custom_environment => {}}).returns('').at_most_once
+        provider.uninstall
+      end
+    end
+
+  end
+
+  describe ".nodigest" do
+    { '4.0'   => nil,
+      '4.0.1' => nil,
+      '4.0.2' => '--nodigest',
+      '4.0.3' => '--nodigest',
+      '4.1'   => '--nodigest',
+      '5'     => '--nodigest',
+    }.each do |version, expected|
+      describe "when current version is #{version}" do
+        it "should return #{expected.inspect}" do
+          subject.stubs(:current_version).returns(version)
+          subject.nodigest.should == expected
+        end
+      end
+    end
+  end
+
+  describe ".nosignature" do
+    { '4.0.3' => nil,
+      '4.1'   => '--nosignature',
+      '4.1.1' => '--nosignature',
+      '4.2'   => '--nosignature',
+      '5'     => '--nosignature',
+    }.each do |version, expected|
+      describe "when current version is #{version}" do
+        it "should return #{expected.inspect}" do
+          subject.stubs(:current_version).returns(version)
+          subject.nosignature.should == expected
+        end
+      end
+    end
+  end
 end

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

@@ -25,6 +25,12 @@ describe provider do
   end
 
   describe 'when installing' do
+    before(:each) do
+      Puppet::Util.stubs(:which).with("rpm").returns("/bin/rpm")
+      provider.stubs(:which).with("rpm").returns("/bin/rpm")
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "--version"], {:combine => true, :custom_environment => {}, :failonfail => true}).returns("4.10.1\n").at_most_once
+    end
+
     it 'should call yum install for :installed' do
       @resource.stubs(:should).with(:ensure).returns :installed
       @provider.expects(:yum).with('-d', '0', '-e', '0', '-y', :install, 'mypackage')
@@ -56,11 +62,6 @@ describe provider do
       @provider.expects(:yum).with('-y', :erase, 'mypackage')
       @provider.purge
     end
-
-    it 'should use rpm to uninstall' do
-      @provider.expects(:rpm).with('-e', 'mypackage-1-1.i386')
-      @provider.uninstall
-    end
   end
 
   it 'should be versionable' do

data/spec/unit/provider/parsedfile_spec.rb

@@ -5,55 +5,97 @@ require 'puppet/provider/parsedfile'
 
 # Most of the tests for this are still in test/ral/provider/parsedfile.rb.
 describe Puppet::Provider::ParsedFile do
-  before do
-    @class = Class.new(Puppet::Provider::ParsedFile)
-  end
+
+  # The ParsedFile provider class is meant to be used as an abstract base class
+  # but also stores a lot of state within the singleton class. To avoid
+  # sharing data between classes we construct an anonymous class that inherits
+  # the ParsedFile provider instead of directly working with the ParsedFile
+  # provider itself.
+  subject { Puppet::Type.newtype(:parsedfile_type).provide(:parsedfile_provider, :parent => described_class) }
 
   describe "when looking up records loaded from disk" do
     it "should return nil if no records have been loaded" do
-      @class.record?("foo").should be_nil
+      subject.record?("foo").should be_nil
     end
   end
 
   describe "when generating a list of instances" do
     it "should return an instance for each record parsed from all of the registered targets" do
-      @class.expects(:targets).returns %w{/one /two}
-      @class.stubs(:skip_record?).returns false
+      subject.expects(:targets).returns %w{/one /two}
+      subject.stubs(:skip_record?).returns false
       one = [:uno1, :uno2]
       two = [:dos1, :dos2]
-      @class.expects(:prefetch_target).with("/one").returns one
-      @class.expects(:prefetch_target).with("/two").returns two
+      subject.expects(:prefetch_target).with("/one").returns one
+      subject.expects(:prefetch_target).with("/two").returns two
 
       results = []
       (one + two).each do |inst|
         results << inst.to_s + "_instance"
-        @class.expects(:new).with(inst).returns(results[-1])
+        subject.expects(:new).with(inst).returns(results[-1])
       end
 
-      @class.instances.should == results
+      subject.instances.should == results
+    end
+
+    it "should ignore target when retrieve fails" do
+      subject.expects(:targets).returns %w{/one /two /three}
+      subject.stubs(:skip_record?).returns false
+      subject.expects(:retrieve).with("/one").returns [
+        {:name => 'target1_record1'},
+        {:name => 'target1_record2'}
+      ]
+      subject.expects(:retrieve).with("/two").raises Puppet::Util::FileType::FileReadError, "some error"
+      subject.expects(:retrieve).with("/three").returns [
+        {:name => 'target3_record1'},
+        {:name => 'target3_record2'}
+      ]
+      Puppet.expects(:err).with('Could not prefetch parsedfile_type provider \'parsedfile_provider\' target \'/two\': some error. Treating as empty')
+      subject.expects(:new).with(:name => 'target1_record1', :on_disk => true, :target => '/one', :ensure => :present).returns 'r1'
+      subject.expects(:new).with(:name => 'target1_record2', :on_disk => true, :target => '/one', :ensure => :present).returns 'r2'
+      subject.expects(:new).with(:name => 'target3_record1', :on_disk => true, :target => '/three', :ensure => :present).returns 'r3'
+      subject.expects(:new).with(:name => 'target3_record2', :on_disk => true, :target => '/three', :ensure => :present).returns 'r4'
+
+      subject.instances.should == %w{r1 r2 r3 r4}
     end
 
     it "should skip specified records" do
-      @class.expects(:targets).returns %w{/one}
-      @class.expects(:skip_record?).with(:uno).returns false
-      @class.expects(:skip_record?).with(:dos).returns true
+      subject.expects(:targets).returns %w{/one}
+      subject.expects(:skip_record?).with(:uno).returns false
+      subject.expects(:skip_record?).with(:dos).returns true
       one = [:uno, :dos]
-      @class.expects(:prefetch_target).returns one
+      subject.expects(:prefetch_target).returns one
+
+      subject.expects(:new).with(:uno).returns "eh"
+      subject.expects(:new).with(:dos).never
+
+      subject.instances
+    end
+  end
 
-      @class.expects(:new).with(:uno).returns "eh"
-      @class.expects(:new).with(:dos).never
+  describe "when matching resources to existing records" do
+    let(:first_resource) { stub(:one, :name => :one) }
+    let(:second_resource) { stub(:two, :name => :two) }
 
-      @class.instances
+    let(:resources) {{:one => first_resource, :two => second_resource}}
+
+    it "returns a resource if the record name matches the resource name" do
+      record = {:name => :one}
+      subject.resource_for_record(record, resources).should be first_resource
+    end
+
+    it "doesn't return a resource if the record name doesn't match any resource names" do
+      record = {:name => :three}
+      subject.resource_for_record(record, resources).should be_nil
     end
   end
 
   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.
-      @class.stubs(:retrieve).returns []
-      @class.default_target = "/foo/bar"
-      @class.initvars
-      @class.prefetch
+      subject.stubs(:retrieve).returns []
+      subject.default_target = "/foo/bar"
+      subject.initvars
+      subject.prefetch
 
       @filetype = Puppet::Util::FileType.filetype(:flat).new("/my/file")
       Puppet::Util::FileType.filetype(:flat).stubs(:new).with("/my/file").returns @filetype
@@ -64,7 +106,7 @@ describe Puppet::Provider::ParsedFile do
     it "should back up the file being written if the filetype can be backed up" do
       @filetype.expects(:backup)
 
-      @class.flush_target("/my/file")
+      subject.flush_target("/my/file")
     end
 
     it "should not try to back up the file if the filetype cannot be backed up" do
@@ -73,22 +115,74 @@ describe Puppet::Provider::ParsedFile do
 
       @filetype.stubs(:write)
 
-      @class.flush_target("/my/file")
+      subject.flush_target("/my/file")
     end
 
     it "should not back up the file more than once between calls to 'prefetch'" do
       @filetype.expects(:backup).once
 
-      @class.flush_target("/my/file")
-      @class.flush_target("/my/file")
+      subject.flush_target("/my/file")
+      subject.flush_target("/my/file")
     end
 
     it "should back the file up again once the file has been reread" do
       @filetype.expects(:backup).times(2)
 
-      @class.flush_target("/my/file")
-      @class.prefetch
-      @class.flush_target("/my/file")
+      subject.flush_target("/my/file")
+      subject.prefetch
+      subject.flush_target("/my/file")
+    end
+  end
+end
+
+describe "A very basic provider based on ParsedFile" do
+
+  let(:input_text) { File.read(my_fixture('simple.txt')) }
+  let(:target) { File.expand_path("/tmp/test") }
+
+  subject do
+    example_provider_class = Class.new(Puppet::Provider::ParsedFile)
+    example_provider_class.default_target = target
+    # Setup some record rules
+    example_provider_class.instance_eval do
+      text_line :text, :match => %r{.}
+    end
+    example_provider_class.initvars
+    example_provider_class.prefetch
+    # evade a race between multiple invocations of the header method
+    example_provider_class.stubs(:header).
+      returns("# HEADER As added by puppet.\n")
+    example_provider_class
+  end
+
+  context "writing file contents back to disk" do
+    it "should not change anything except from adding a header" do
+      input_records = subject.parse(input_text)
+      subject.to_file(input_records).
+        should match subject.header + input_text
+    end
+  end
+
+  context "rewriting a file containing a native header" do
+    let(:regex) { %r/^# HEADER.*third party\.\n/ }
+    let(:input_records) { subject.parse(input_text) }
+
+    before :each do
+      subject.stubs(:native_header_regex).returns(regex)
+    end
+
+    it "should move the native header to the top" do
+      subject.to_file(input_records).should_not match /\A#{subject.header}/
+    end
+
+    context "and dropping native headers found in input" do
+      before :each do
+        subject.stubs(:drop_native_header).returns(true)
+      end
+
+      it "should not include the native header in the output" do
+        subject.to_file(input_records).should_not match regex
+      end
     end
   end
 end

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

@@ -54,4 +54,22 @@ OUTPUT
 
     @provider.rcvar_value.should == "YES"
   end
+
+  it "should find the right rcvar_name" do
+    @provider.stubs(:rcvar).returns(['# ntpd', 'ntpd_enable="YES"'])
+
+    @provider.rcvar_name.should == "ntpd"
+  end
+
+  it "should enable only the selected service" do
+    File.stubs(:exists?).with('/etc/rc.conf').returns(true)
+    File.stubs(:read).with('/etc/rc.conf').returns("openntpd_enable=\"NO\"\nntpd_enable=\"NO\"\n")
+    fh = stub 'fh'
+    File.stubs(:open).with('/etc/rc.conf', File::WRONLY).yields(fh)
+    fh.expects(:<<).with("openntpd_enable=\"NO\"\nntpd_enable=\"YES\"\n")
+    File.stubs(:exists?).with('/etc/rc.conf.local').returns(false)
+    File.stubs(:exists?).with('/etc/rc.conf.d/ntpd').returns(false)
+
+    @provider.rc_replace('ntpd', 'ntpd', 'YES')
+  end
 end

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

@@ -5,141 +5,155 @@
 
 require 'spec_helper'
 
-provider_class = Puppet::Type.type(:service).provider(:init)
+describe Puppet::Type.type(:service).provider(:init) do
 
-describe provider_class do
+  let :provider do
+    provider = described_class.new(:name => 'myservice')
+    provider.resource = resource
+    provider
+  end
 
-  before :each do
-    @class = Puppet::Type.type(:service).provider(:init)
-    @resource = stub 'resource'
-    @resource.stubs(:[]).returns(nil)
-    @resource.stubs(:[]).with(:name).returns "myservice"
-    @resource.stubs(:[]).with(:path).returns ["/service/path","/alt/service/path"]
-    File.stubs(:directory?).returns(true)
+  let :resource do
+    Puppet::Type.type(:service).new(
+      :name     => 'myservice',
+      :ensure   => :running,
+      :path     => paths
+    )
+  end
 
-    @provider = provider_class.new
-    @provider.resource = @resource
+  let :paths do
+    ["/service/path","/alt/service/path"]
+  end
+
+  let :excludes do
+    # Taken from redhat, gentoo, and debian
+    %w{functions.sh reboot.sh shutdown.sh functions halt killall single linuxconf reboot boot wait-for-state}
   end
 
   describe "when getting all service instances" do
     before :each do
+      described_class.stubs(:defpath).returns('tmp')
+
       @services = ['one', 'two', 'three', 'four']
-      Dir.stubs(:entries).returns @services
-      FileTest.stubs(:directory?).returns(true)
+      Dir.stubs(:entries).with('tmp').returns @services
+      FileTest.expects(:directory?).with('tmp').returns(true)
       FileTest.stubs(:executable?).returns(true)
-      @class.stubs(:defpath).returns('tmp')
     end
 
     it "should return instances for all services" do
-      @services.each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
-      end
-      results = @services.collect {|x| "#{x}_instance"}
-
-      @class.instances.should == results
+      described_class.instances.map(&:name).should == @services
     end
 
     it "should omit an array of services from exclude list" do
       exclude = ['two', 'four']
-      (@services - exclude).each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
-      end
-      results = (@services-exclude).collect {|x| "#{x}_instance"}
-
-      @class.get_services(@class.defpath, exclude).should == results
+      described_class.get_services(described_class.defpath, exclude).map(&:name).should == (@services - exclude)
     end
 
     it "should omit a single service from the exclude list" do
       exclude = 'two'
-      (@services - [exclude]).each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst}.returns("#{inst}_instance")
-      end
-      results = @services.reject{|x| x == exclude }.collect {|x| "#{x}_instance"}
-
-      @class.get_services(@class.defpath, exclude).should == results
+      described_class.get_services(described_class.defpath, exclude).map(&:name).should == @services - [exclude]
     end
 
     it "should use defpath" do
-      @services.each do |inst|
-        @class.expects(:new).with{|hash| hash[:path] == @class.defpath}.returns("#{inst}_instance")
-      end
-      results = @services.sort.collect {|x| "#{x}_instance"}
-
-      @class.instances.sort.should == results
+      described_class.instances.should be_all { |provider| provider.get(:path) == described_class.defpath }
     end
 
     it "should set hasstatus to true for providers" do
-      @services.each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst && hash[:hasstatus] == true}.returns("#{inst}_instance")
-      end
-      results = @services.collect {|x| "#{x}_instance"}
-
-      @class.instances.should == results
+      described_class.instances.should be_all { |provider| provider.get(:hasstatus) == true }
     end
 
     it "should discard upstart jobs" do
       not_init_service, *valid_services = @services
-      valid_services.each do |inst|
-        @class.expects(:new).with{|hash| hash[:name] == inst && hash[:hasstatus] == true}.returns("#{inst}_instance")
-      end
-      File.stubs(:symlink?).returns(false)
+      File.stubs(:symlink?).returns false
       File.stubs(:symlink?).with("tmp/#{not_init_service}").returns(true)
       File.stubs(:readlink).with("tmp/#{not_init_service}").returns("/lib/init/upstart-job")
 
-      results = valid_services.collect {|x| "#{x}_instance"}
-      @class.instances.should == results
+      described_class.instances.map(&:name).should == valid_services
+    end
+
+    it "should discard non-initscript scripts" do
+      valid_services = @services
+      all_services = valid_services + excludes
+      Dir.expects(:entries).with('tmp').returns all_services
+      described_class.instances.map(&:name).should =~ valid_services
     end
   end
 
-  describe "when searching for the init script" do
+  describe "when checking valid paths" do
     it "should discard paths that do not exist" do
-      File.stubs(:exist?).returns(false)
-      File.stubs(:directory?).returns(false)
-      @provider.paths.should be_empty
+      File.expects(:directory?).with(paths[0]).returns false
+      File.expects(:exist?).with(paths[0]).returns false
+      File.expects(:directory?).with(paths[1]).returns true
+
+      provider.paths.should == [paths[1]]
     end
 
     it "should discard paths that are not directories" do
-      File.stubs(:exist?).returns(true)
-      File.stubs(:directory?).returns(false)
-      @provider.paths.should be_empty
+      paths.each do |path|
+        File.expects(:exist?).with(path).returns true
+        File.expects(:directory?).with(path).returns false
+      end
+      provider.paths.should be_empty
     end
+  end
 
-    it "should be able to find the init script in the service path" do
-      File.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
-      File.expects(:stat).with("/service/path/myservice").returns true
-      @provider.initscript.should == "/service/path/myservice"
+  describe "when searching for the init script" do
+    before :each do
+      paths.each {|path| File.expects(:directory?).with(path).returns true }
     end
+
     it "should be able to find the init script in the service path" do
-      File.stubs(:stat).raises(Errno::ENOENT.new('No such file or directory'))
-      File.expects(:stat).with("/alt/service/path/myservice").returns true
-      @provider.initscript.should == "/alt/service/path/myservice"
+      File.expects(:stat).with("#{paths[0]}/myservice").returns true
+      File.expects(:stat).with("#{paths[1]}/myservice").never # first one wins
+      provider.initscript.should == "/service/path/myservice"
     end
+
+    it "should be able to find the init script in an alternate service path" do
+      File.expects(:stat).with("#{paths[0]}/myservice").raises Errno::ENOENT, "No such file or directory - #{paths[0]}/myservice"
+      File.expects(:stat).with("#{paths[1]}/myservice").returns true
+      provider.initscript.should == "/alt/service/path/myservice"
+    end
+
+    it "should be able to find the init script if it ends with .sh" do
+      File.expects(:stat).with("#{paths[0]}/myservice").raises Errno::ENOENT, "No such file or directory - #{paths[0]}/myservice"
+      File.expects(:stat).with("#{paths[1]}/myservice").raises Errno::ENOENT, "No such file or directory - #{paths[1]}/myservice"
+      File.expects(:stat).with("#{paths[0]}/myservice.sh").returns true
+      provider.initscript.should == "/service/path/myservice.sh"
+    end
+
     it "should fail if the service isn't there" do
-      lambda { @provider.initscript }.should raise_error(Puppet::Error, "Could not find init script for 'myservice'")
+      paths.each do |path|
+        File.expects(:stat).with("#{path}/myservice").raises Errno::ENOENT, "No such file or directory - #{path}/myservice"
+        File.expects(:stat).with("#{path}/myservice.sh").raises Errno::ENOENT, "No such file or directory - #{path}/myservice.sh"
+      end
+      expect { provider.initscript }.to raise_error(Puppet::Error, "Could not find init script for 'myservice'")
     end
   end
 
   describe "if the init script is present" do
     before :each do
+      File.stubs(:directory?).with("/service/path").returns true
+      File.stubs(:directory?).with("/alt/service/path").returns true
       File.stubs(:stat).with("/service/path/myservice").returns true
     end
 
     [:start, :stop, :status, :restart].each do |method|
       it "should have a #{method} method" do
-        @provider.should respond_to(method)
+        provider.should respond_to(method)
       end
       describe "when running #{method}" do
 
         it "should use any provided explicit command" do
-          @resource.stubs(:[]).with(method).returns "/user/specified/command"
-          @provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
-          @provider.send(method)
+          resource[method] = "/user/specified/command"
+          provider.expects(:execute).with { |command, *args| command == ["/user/specified/command"] }
+          provider.send(method)
         end
 
         it "should pass #{method} to the init script when no explicit command is provided" do
-          @resource.stubs(:[]).with("has#{method}".intern).returns :true
-          @provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
-          @provider.send(method)
+          resource[:hasrestart] = :true
+          resource[:hasstatus] = :true
+          provider.expects(:execute).with { |command, *args| command ==  ["/service/path/myservice",method]}
+          provider.send(method)
         end
       end
     end
@@ -147,45 +161,52 @@ describe provider_class do
     describe "when checking status" do
       describe "when hasstatus is :true" do
         before :each do
-          @resource.stubs(:[]).with(:hasstatus).returns :true
+          resource[:hasstatus] = :true
         end
         it "should execute the command" do
-          @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
-          @provider.status
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          provider.status
         end
         it "should consider the process running if the command returns 0" do
-          @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+          provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
           $CHILD_STATUS.stubs(:exitstatus).returns(0)
-          @provider.status.should == :running
+          provider.status.should == :running
         end
         [-10,-1,1,10].each { |ec|
           it "should consider the process stopped if the command returns something non-0" do
-            @provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
+            provider.expects(:texecute).with(:status, ['/service/path/myservice', :status], false).returns("")
             $CHILD_STATUS.stubs(:exitstatus).returns(ec)
-            @provider.status.should == :stopped
+            provider.status.should == :stopped
           end
         }
       end
       describe "when hasstatus is not :true" do
+        before :each do
+          resource[:hasstatus] = :false
+        end
+
         it "should consider the service :running if it has a pid" do
-          @provider.expects(:getpid).returns "1234"
-          @provider.status.should == :running
+          provider.expects(:getpid).returns "1234"
+          provider.status.should == :running
         end
         it "should consider the service :stopped if it doesn't have a pid" do
-          @provider.expects(:getpid).returns nil
-          @provider.status.should == :stopped
+          provider.expects(:getpid).returns nil
+          provider.status.should == :stopped
         end
       end
     end
 
     describe "when restarting and hasrestart is not :true" do
+      before :each do
+        resource[:hasrestart] = :false
+      end
+
       it "should stop and restart the process" do
-        @provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
-        @provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
+        provider.expects(:texecute).with(:stop, ['/service/path/myservice', :stop ], true).returns("")
+        provider.expects(:texecute).with(:start,['/service/path/myservice', :start], true).returns("")
         $CHILD_STATUS.stubs(:exitstatus).returns(0)
-        @provider.restart
+        provider.restart
       end
     end
-
   end
 end