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

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

@@ -1,6 +1,8 @@
+#!/usr/bin/env ruby
+
 require 'spec_helper'
 
-describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.features.microsoft_windows? do
+describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet::Util::Platform.windows? do
   let(:resource) do
     Puppet::Type.type(:user).new(
       :title => 'testuser',
@@ -11,20 +13,20 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   let(:provider) { resource.provider }
 
-  let(:connection) { double('connection') }
+  let(:connection) { stub 'connection' }
 
   before :each do
-    allow(Puppet::Util::Windows::ADSI).to receive(:computer_name).and_return('testcomputername')
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(connection)
+    Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
     # this would normally query the system, but not needed for these tests
-    allow(Puppet::Util::Windows::ADSI::User).to receive(:localized_domains).and_return([])
+    Puppet::Util::Windows::ADSI::User.stubs(:localized_domains).returns([])
   end
 
   describe ".instances" do
     it "should enumerate all users" do
       names = ['user1', 'user2', 'user3']
-      stub_users = names.map {|n| double(:name => n)}
-      allow(connection).to receive(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').and_return(stub_users)
+      stub_users = names.map{|n| stub(:name => n)}
+      connection.stubs(:execquery).with('select name from win32_useraccount where localaccount = "TRUE"').returns(stub_users)
 
       expect(described_class.instances.map(&:name)).to match(names)
     end
@@ -37,8 +39,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   describe "when retrieving the password property" do
     context "when the resource has a nil password" do
       it "should never issue a logon attempt" do
-        allow(resource).to receive(:[]).with(eq(:name).or(eq(:password))).and_return(nil)
-        expect(Puppet::Util::Windows::User).not_to receive(:logon_user)
+        resource.stubs(:[]).with(any_of(:name, :password)).returns(nil)
+        Puppet::Util::Windows::User.expects(:logon_user).never
         provider.password
       end
     end
@@ -46,41 +48,42 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   describe "when managing groups" do
     it 'should return the list of groups as an array of strings' do
-      allow(provider.user).to receive(:groups).and_return(nil)
+      provider.user.stubs(:groups).returns nil
       groups = {'group1' => nil, 'group2' => nil, 'group3' => nil}
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:name_sid_hash).and_return(groups)
+      Puppet::Util::Windows::ADSI::Group.expects(:name_sid_hash).returns(groups)
 
       expect(provider.groups).to eq(groups.keys)
     end
 
     it "should return an empty array if there are no groups" do
-      allow(provider.user).to receive(:groups).and_return([])
+      provider.user.stubs(:groups).returns []
 
       expect(provider.groups).to eq([])
     end
 
     it 'should be able to add a user to a set of groups' do
       resource[:membership] = :minimum
-      expect(provider.user).to receive(:set_groups).with('group1,group2', true)
+      provider.user.expects(:set_groups).with('group1,group2', true)
 
       provider.groups = 'group1,group2'
 
       resource[:membership] = :inclusive
-      expect(provider.user).to receive(:set_groups).with('group1,group2', false)
+      provider.user.expects(:set_groups).with('group1,group2', false)
 
       provider.groups = 'group1,group2'
     end
   end
 
   describe "#groups_insync?" do
-    let(:group1) { double(:account => 'group1', :domain => '.', :sid => 'group1sid') }
-    let(:group2) { double(:account => 'group2', :domain => '.', :sid => 'group2sid') }
-    let(:group3) { double(:account => 'group3', :domain => '.', :sid => 'group3sid') }
+
+    let(:group1) { stub(:account => 'group1', :domain => '.', :sid => 'group1sid') }
+    let(:group2) { stub(:account => 'group2', :domain => '.', :sid => 'group2sid') }
+    let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group1', any_args).and_return(group1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group2', any_args).and_return(group2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('group3', any_args).and_return(group3)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group1').returns(group1)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group2').returns(group2)
+      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('group3').returns(group3)
     end
 
     it "should return true for same lists of members" do
@@ -188,16 +191,17 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:comment]    = 'a test user'
       resource[:home]       = 'C:\Users\testuser'
 
-      user = double('user')
-      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
+      user = stub 'user'
+      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
 
-      allow(user).to receive(:groups).and_return(['group2', 'group3'])
+      user.stubs(:groups).returns(['group2', 'group3'])
 
-      expect(user).to receive(:password=).ordered
-      expect(user).to receive(:commit).ordered
-      expect(user).to receive(:set_groups).with('group1,group2', false).ordered
-      expect(user).to receive(:[]=).with('Description', 'a test user')
-      expect(user).to receive(:[]=).with('HomeDirectory', 'C:\Users\testuser')
+      create = sequence('create')
+      user.expects(:password=).in_sequence(create)
+      user.expects(:commit).in_sequence(create)
+      user.expects(:set_groups).with('group1,group2', false).in_sequence(create)
+      user.expects(:[]=).with('Description', 'a test user')
+      user.expects(:[]=).with('HomeDirectory', 'C:\Users\testuser')
 
       provider.create
     end
@@ -206,28 +210,22 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:password] = '0xDeadBeef'
       resource[:managehome] = true
 
-      user = double('user')
-      allow(user).to receive(:password=)
-      allow(user).to receive(:commit)
-      allow(user).to receive(:[]=)
-      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_return(user)
-      expect(Puppet::Util::Windows::User).to receive(:load_profile).with('testuser', '0xDeadBeef')
+      user = stub_everything 'user'
+      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').returns user
+      Puppet::Util::Windows::User.expects(:load_profile).with('testuser', '0xDeadBeef')
 
       provider.create
     end
 
     it "should set a user's password" do
-      expect(provider.user).to receive(:disabled?).and_return(false)
-      expect(provider.user).to receive(:locked_out?).and_return(false)
-      expect(provider.user).to receive(:expired?).and_return(false)
-      expect(provider.user).to receive(:password=).with('plaintextbad')
+      provider.user.expects(:password=).with('plaintextbad')
 
       provider.password = "plaintextbad"
     end
 
     it "should test a valid user password" do
       resource[:password] = 'plaintext'
-      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(true)
+      provider.user.expects(:password_is?).with('plaintext').returns true
 
       expect(provider.password).to eq('plaintext')
 
@@ -235,54 +233,57 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
     it "should test a bad user password" do
       resource[:password] = 'plaintext'
-      expect(provider.user).to receive(:password_is?).with('plaintext').and_return(false)
+      provider.user.expects(:password_is?).with('plaintext').returns false
 
       expect(provider.password).to be_nil
     end
 
     it "should test a blank user password" do
       resource[:password] = ''
-      expect(provider.user).to receive(:password_is?).with('').and_return(true)
+      provider.user.expects(:password_is?).with('').returns true
 
       expect(provider.password).to eq('')
     end
 
     it 'should not create a user if a group by the same name exists' do
-      expect(Puppet::Util::Windows::ADSI::User).to receive(:create).with('testuser').and_raise(Puppet::Error.new("Cannot create user if group 'testuser' exists."))
+      Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').raises( Puppet::Error.new("Cannot create user if group 'testuser' exists.") )
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
 
     it "should fail with an actionable message when trying to create an active directory user" do
       resource[:name] = 'DOMAIN\testdomainuser'
-      expect(Puppet::Util::Windows::ADSI::Group).to receive(:exists?).with(resource[:name]).and_return(false)
-      expect(connection).to receive(:Create)
-      expect(connection).to receive(:Get).with('UserFlags')
-      expect(connection).to receive(:Put).with('UserFlags', true)
-      expect(connection).to receive(:SetInfo).and_raise(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)
+      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      connection.expects(:Get).with('UserFlags')
+      connection.expects(:Put).with('UserFlags', true)
+      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 users/
+      )
     end
   end
 
   it 'should be able to test whether a user exists' do
-    allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).and_return(nil)
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(double('connection', :Class => 'User'))
+    Puppet::Util::Windows::SID.stubs(:name_to_principal).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'User')
     expect(provider).to be_exists
 
-    allow(Puppet::Util::Windows::ADSI).to receive(:connect).and_return(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
     expect(provider).not_to be_exists
   end
 
   it 'should be able to delete a user' do
-    expect(connection).to receive(:Delete).with('user', 'testuser')
+    connection.expects(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it 'should not run commit on a deleted user' do
-    expect(connection).to receive(:Delete).with('user', 'testuser')
-    expect(connection).not_to receive(:SetInfo)
+    connection.expects(:Delete).with('user', 'testuser')
+    connection.expects(:SetInfo).never
 
     provider.delete
     provider.flush
@@ -292,33 +293,33 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     resource[:managehome] = true
 
     sid = 'S-A-B-C'
-    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return(sid)
-    expect(Puppet::Util::Windows::ADSI::UserProfile).to receive(:delete).with(sid)
-    expect(connection).to receive(:Delete).with('user', 'testuser')
+    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns(sid)
+    Puppet::Util::Windows::ADSI::UserProfile.expects(:delete).with(sid)
+    connection.expects(:Delete).with('user', 'testuser')
 
     provider.delete
   end
 
   it "should commit the user when flushed" do
-    expect(provider.user).to receive(:commit)
+    provider.user.expects(:commit)
 
     provider.flush
   end
 
   it "should return the user's SID as uid" do
-    expect(Puppet::Util::Windows::SID).to receive(:name_to_sid).with('testuser').and_return('S-1-5-21-1362942247-2130103807-3279964888-1111')
+    Puppet::Util::Windows::SID.expects(:name_to_sid).with('testuser').returns('S-1-5-21-1362942247-2130103807-3279964888-1111')
 
     expect(provider.uid).to eq('S-1-5-21-1362942247-2130103807-3279964888-1111')
   end
 
   it "should fail when trying to manage the uid property" do
-    expect(provider).to receive(:fail).with(/uid is read-only/)
+    provider.expects(:fail).with { |msg| msg =~ /uid is read-only/ }
     provider.send(:uid=, 500)
   end
 
   [:gid, :shell].each do |prop|
     it "should fail when trying to manage the #{prop} property" do
-      expect(provider).to receive(:fail).with(/No support for managing property #{prop}/)
+      provider.expects(:fail).with { |msg| msg =~ /No support for managing property #{prop}/ }
       provider.send("#{prop}=", 'foo')
     end
   end

data/spec/unit/provider_spec.rb

@@ -1,7 +1,8 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 def existing_command
-  Puppet.features.microsoft_windows? ? "cmd" : "echo"
+  Puppet::Util::Platform.windows? ? "cmd" : "echo"
 end
 
 describe Puppet::Provider do
@@ -12,6 +13,7 @@ describe Puppet::Provider do
   end
 
   after :each do
+    Puppet::Type.type(:test).provider_hash.clear
     Puppet::Type.rmtype(:test)
   end
 
@@ -148,13 +150,13 @@ describe Puppet::Provider do
     # otherwise is to assign it to a constant, and that hurts more here in
     # testing world. --daniel 2012-01-29
     a = Class.new(Puppet::Provider).new(res)
-    allow(a.class).to receive(:name).and_return("Puppet::Provider::Notify::A")
+    a.class.stubs(:name).returns "Puppet::Provider::Notify::A"
 
     b = Class.new(Puppet::Provider).new(res)
-    allow(b.class).to receive(:name).and_return("Puppet::Provider::Notify::B")
+    b.class.stubs(:name).returns "Puppet::Provider::Notify::B"
 
     c = Class.new(Puppet::Provider).new(res)
-    allow(c.class).to receive(:name).and_return("Puppet::Provider::Notify::C")
+    c.class.stubs(:name).returns "Puppet::Provider::Notify::C"
 
     [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
       expect(this.sort).to eq([a, b, c])
@@ -280,7 +282,7 @@ describe Puppet::Provider do
 
     describe "regex matches" do
       it "should match a singular regex" do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
+        Facter.expects(:value).with(:osfamily).at_least_once.returns "solaris"
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -290,7 +292,7 @@ describe Puppet::Provider do
       end
 
       it "should not match a non-matching regex " do
-        expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("redhat")
+        Facter.expects(:value).with(:osfamily).at_least_once.returns "redhat"
 
         one = type.provide(:one) do
           defaultfor :osfamily => /solaris/
@@ -301,8 +303,8 @@ describe Puppet::Provider do
 
       it "should allow a mix of regex and string" do
 
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return("fedora")
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("24")
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
+        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
 
         one = type.provide(:one) do
           defaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => /^2[2-9]$/
@@ -326,14 +328,14 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for the first defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for the last defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -350,23 +352,23 @@ describe Puppet::Provider do
       let(:alternate) { type.provide(:alternate) {} }
 
       it "should be default for a more specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os2)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os2
+        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a more specific, but matching, defaultfor with regex" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os3)
-        expect(Facter).to receive(:value).with(:operatingsystemmajrelease).at_least(:once).and_return("42")
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os3
+        Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "42"
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
       end
 
       it "should be default for a less specific, but matching, defaultfor" do
-        expect(Facter).to receive(:value).with(:operatingsystem).at_least(:once).and_return(:os1)
+        Facter.expects(:value).with(:operatingsystem).at_least_once.returns :os1
 
         expect(provider).to be_default
         expect(alternate).not_to be_default
@@ -389,26 +391,173 @@ describe Puppet::Provider do
       expect(subject).not_to be_default
     end
 
-    it "should consider two defaults to be higher specificity than one default" do
-      expect(Facter).to receive(:value).with(:osfamily).at_least(:once).and_return("solaris")
-      expect(Facter).to receive(:value).with(:operatingsystemrelease).at_least(:once).and_return("5.10")
+    it "should not be default if the notdefaultfor does match" do
+      Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
+      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
 
       one = type.provide(:one) do
-        defaultfor :osfamily => "solaris"
+        defaultfor :operatingsystem => "fedora"
+        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 24
       end
 
-      two = type.provide(:two) do
-        defaultfor :osfamily => "solaris", :operatingsystemrelease => "5.10"
-      end
-
-      expect(two.specificity).to be > one.specificity
+      expect(one).not_to be_default
     end
 
-    it "should consider a subclass more specific than its parent class" do
-      parent = type.provide(:parent)
-      child  = type.provide(:child, :parent => parent)
+    it "should be default if the notdefaultfor doesn't match" do
+      Facter.expects(:value).with(:operatingsystem).at_least_once.returns "fedora"
+      Facter.expects(:value).with(:operatingsystemmajrelease).at_least_once.returns "24"
+
+      one = type.provide(:one) do
+        defaultfor :operatingsystem => "fedora"
+        notdefaultfor :operatingsystem => "fedora", :operatingsystemmajrelease => 42
+      end
+
+      expect(one).to be_default
+    end
+
+    # Key: spec has 4 required and 1 optional part:
+    # one-defaultfor, one-notdefaultfor, two-defaultfor, two-notdefaultfor
+    # d = defaultfor, n = notdefaultfor,
+    # d2 - two clauses in defaultfor constraint,
+    # ! = constraint exists but doesn't match
+    # none = no constraint
+    # d+/!d+/none+ - provider class has deeper inheritence
+
+    context "defaultfor/notdefaultfor configurable tests" do
+      [
+        # Two default? group - ties go to first to register
+        %w{d    none d     none pickone},
+        # Two default? group - second is selected for specificity
+        %w{d    !n   d2     !n         },
+        %w{d    !n   d2     none       },
+        # Two default? group - second is selected for inheritence
+        %w{d    !n   d+     !n         },
+        %w{d    !n   d+     none       },
+        # One default? group - second (only default?) always is selected
+        %w{!d   !n   d     none        },
+        %w{!d   !n   d     !n          },
+        %w{!d   n    d     none        },
+        %w{!d   n    d     !n          },
+        %w{d    n    d     none        },
+        %w{d    n    d     !n          },
+        # No default? group:
+        %w{d    !n   d     !n   pickone},
+        %w{d    !n   d     none pickone},
+        %w{!d   !n   !d    !n   pickone},
+        %w{!d   !n   !d    none pickone},
+        %w{!d   none !d    none pickone},
+        %w{none !n   none  !n   pickone},
+        %w{none none none  none pickone},
+        # No default? but deeper class inheritence group:
+        %w{!d   !n   !d+   !n          },
+        %w{!d   !n   !d+   none        },
+        %w{!d   none !d+   none        },
+        %w{none !n   none+ !n          },
+        %w{none none none+ none        },
+      ].each do |thisspec|
+
+        defaultforspec = {
+          :one => {},
+          :two => {},
+          :expect_one => false #Default expectation is to expect provider two for these tests
+        }
+
+        fail "Inheritence not supported on first provider" if thisspec[0].end_with?('+')
+
+        case thisspec[0] # First provider defaultfor spec
+        when 'd'
+          defaultforspec[:one][:defaultfor] = true
+        when '!d'
+          defaultforspec[:one][:defaultfor] = false
+        when 'none'
+          # Do not include a defaultfor constraint
+        else
+          fail "Did not understand first spec: %{spec}" % { spec: thisspec[0] }
+        end
+
+        case thisspec[1] # First provider notdefaultfor spec
+        when 'n'
+          defaultforspec[:one][:notdefaultfor] = true
+        when '!n'
+          defaultforspec[:one][:notdefaultfor] = false
+        when 'none'
+          # Do not include a notdefaultfor constraint
+        else
+          fail "Did not understand second spec: %{spec}" % { spec: thisspec[1] }
+        end
+
+        if thisspec[2].end_with?('+') then # d+ !d+ none+
+          defaultforspec[:two][:derived] = true
+          thisspec[2] = thisspec[2][0 .. -2]
+        end
+
+        case thisspec[2]
+        when 'd'
+          defaultforspec[:two][:defaultfor] = true
+        when 'd2'
+          defaultforspec[:two][:extradefaultfor] = true
+        when '!d'
+          defaultforspec[:two][:defaultfor] = false
+        when 'none'
+          # Do not include a defaultfor constraint
+        else
+          fail "Did not understand third spec: %{spec}" % { spec: thisspec[2] }
+        end
+
+        case thisspec[3] # Second provider notdefaultfor spec
+        when 'n'
+          defaultforspec[:two][:notdefaultfor] = true
+        when '!n'
+          defaultforspec[:two][:notdefaultfor] = false
+        when 'none'
+          # Do not include a notdefaultfor constraint
+        else
+          fail "Did not understand fourth spec: %{spec}" % { spec: thisspec[3] }
+        end
+
+        if thisspec.length == 5 && thisspec[4] == "pickone" then
+          defaultforspec[:expect_one] = true
+        end
 
-      expect(child.specificity).to be > parent.specificity
+        it "with the specification: %{spec}" % { spec: thisspec.join(', ') } do
+          Facter.stubs(:value).with(:osfamily).returns "redhat"
+          Facter.stubs(:value).with(:operatingsystem).returns "centos"
+          Facter.stubs(:value).with(:operatingsystemrelease).returns "27"
+
+          one = type.provide(:one) do
+            if defaultforspec[:one].key?(:defaultfor)
+              defaultfor    :osfamily               => "redhat" if  defaultforspec[:one][:defaultfor]
+              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:one][:defaultfor]
+            end
+            if defaultforspec[:one].key?(:notdefaultfor)
+              notdefaultfor :operatingsystem        => "centos" if  defaultforspec[:one][:notdefaultfor]
+              notdefaultfor :operatingsystem        => "ubuntu" if !defaultforspec[:one][:notdefaultfor]
+            end
+          end
+
+          provider_options = {}
+          provider_options[:parent] = one if defaultforspec[:two][:derived] # :two inherits from one, if spec'd
+          two = type.provide(:two, provider_options) do
+            if defaultforspec[:two].key?(:defaultfor) || defaultforspec[:two].key?(:extradefaultfor)
+              defaultfor    :osfamily               => "redhat" if  defaultforspec[:two][:defaultfor]
+              defaultfor    :osfamily               => "redhat",#   defaultforspec[:two][:extradefaultfor] has two parts
+                            :operatingsystem        => "centos" if  defaultforspec[:two][:extradefaultfor]
+              defaultfor    :osfamily               => "ubuntu" if !defaultforspec[:two][:defaultfor]
+            end
+            if defaultforspec[:two].key?(:notdefaultfor)
+              notdefaultfor :operatingsystemrelease => "27" if  defaultforspec[:two][:notdefaultfor]
+              notdefaultfor :operatingsystemrelease => "99" if !defaultforspec[:two][:notdefaultfor]
+            end
+          end
+
+          if defaultforspec[:expect_one] then
+            Puppet.expects(:warning).with(regexp_matches(/Found multiple default providers/))
+            expect(type.defaultprovider).to eq(one)
+          else
+            expect(type.defaultprovider).to eq(two)
+          end
+        end
+      end
     end
 
     describe "using a :feature key" do
@@ -458,7 +607,7 @@ describe Puppet::Provider do
       subject.commands :testing => "puppet-bug-1197"
       expect(subject.command(:testing)).to be_nil
 
-      allow(subject).to receive(:which).with("puppet-bug-1197").and_return("/puppet-bug-1197")
+      subject.stubs(:which).with("puppet-bug-1197").returns("/puppet-bug-1197")
       expect(subject.command(:testing)).to eq("/puppet-bug-1197")
 
       # Ideally, we would also test that `suitable?` returned the right thing
@@ -494,43 +643,43 @@ describe Puppet::Provider do
 
   context "execution" do
     before :each do
-      expect(Puppet).not_to receive(:deprecation_warning)
+      Puppet.expects(:deprecation_warning).never
     end
 
     it "delegates instance execute to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
+      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
 
       provider.new.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates class execute to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execute).with("a_command", { :option => "value" })
+      Puppet::Util::Execution.expects(:execute).with("a_command", { :option => "value" })
 
       provider.send(:execute, "a_command", { :option => "value" })
     end
 
     it "delegates instance execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
+      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
 
       provider.new.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates class execpipe to Puppet::Util::Execution" do
       block = Proc.new { }
-      expect(Puppet::Util::Execution).to receive(:execpipe).with("a_command", true, block)
+      Puppet::Util::Execution.expects(:execpipe).with("a_command", true, block)
 
       provider.send(:execpipe, "a_command", true, block)
     end
 
     it "delegates instance execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
+      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
 
       provider.new.send(:execfail, "a_command", "an exception to raise")
     end
 
     it "delegates class execfail to Puppet::Util::Execution" do
-      expect(Puppet::Util::Execution).to receive(:execfail).with("a_command", "an exception to raise")
+      Puppet::Util::Execution.expects(:execfail).with("a_command", "an exception to raise")
 
       provider.send(:execfail, "a_command", "an exception to raise")
     end
@@ -754,17 +903,16 @@ describe Puppet::Provider do
 
   def expect_command_executed(name, path, *args)
     command = Puppet::Provider::Command.new(name, path, Puppet::Util, Puppet::Util::Execution)
-    args = [no_args] if args.empty?
-    expect(command).to receive(:execute).with(*args)
+    command.expects(:execute).with(*args)
     command
   end
 
   def allow_creation_of(command, environment = {})
-      allow(Puppet::Provider::Command).to receive(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).and_return(command)
+      Puppet::Provider::Command.stubs(:new).with(command.name, command.executable, Puppet::Util, Puppet::Util::Execution, { :failonfail => true, :combine => true, :custom_environment => environment }).returns(command)
   end
 
   def file_exists_and_is_executable(path)
-    expect(FileTest).to receive(:file?).with(path).and_return(true)
-    expect(FileTest).to receive(:executable?).with(path).and_return(true)
+    FileTest.expects(:file?).with(path).returns(true)
+    FileTest.expects(:executable?).with(path).returns(true)
   end
 end