puppet 6.19.0-x86-mingw32 → 7.3.0-x86-mingw32

data/spec/unit/pops/types/type_factory_spec.rb

@@ -151,7 +151,7 @@ describe 'The type factory' do
       expect(hc.class_name).to eq('x')
     end
 
-    it 'array_of(fixnum) returns PArrayType[PIntegerType]' do
+    it 'array_of(integer) returns PArrayType[PIntegerType]' do
       at = TypeFactory.array_of(1)
       expect(at.class()).to eq(PArrayType)
       expect(at.element_type.class).to eq(PIntegerType)

data/spec/unit/pops/validator/validator_spec.rb

@@ -179,17 +179,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_KEY)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
@@ -310,17 +310,17 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::DUPLICATE_DEFAULT)
     end
 
-    it 'produces a warning for virtual class resource' do
+    it 'produces an error for virtual class resource' do
       acceptor = validate(parse('@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
 
-    it 'produces a warning for exported class resource' do
+    it 'produces an error for exported class resource' do
       acceptor = validate(parse('@@class { test: }'))
-      expect(acceptor.warning_count).to eql(1)
-      expect(acceptor.error_count).to eql(0)
+      expect(acceptor.warning_count).to eql(0)
+      expect(acceptor.error_count).to eql(1)
       expect(acceptor).to have_issue(Puppet::Pops::Issues::CLASS_NOT_VIRTUALIZABLE)
     end
   end
@@ -344,16 +344,16 @@ describe "validating 4x" do
       end
     end
 
-    it 'produces an error for application' do
-      acceptor = validate(parse('application test {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for application' do
+      expect {
+        parse('application test {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
     end
 
-    it 'produces an error for capability mapping' do
-      acceptor = validate(parse('Foo produces Sql {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for capability mapping' do
+      expect {
+        parse('Foo produces Sql {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
     end
 
     it 'produces an error for collect expressions with virtual query' do
@@ -410,10 +410,10 @@ describe "validating 4x" do
       expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
     end
 
-    it 'produces an error for site definitions' do
-      acceptor = validate(parse('site {}'))
-      expect(acceptor.error_count).to eql(1)
-      expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+    it 'produces a syntax error for site definitions' do
+      expect {
+        parse('site {}')
+      }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
     end
 
     context 'validating apply() blocks' do
@@ -468,16 +468,16 @@ describe "validating 4x" do
         expect(acceptor.error_count).to eql(0)
       end
 
-      it 'produces an error for application' do
-        acceptor = validate(parse('apply("foo.example.com") { application test {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      it 'produces a syntax error for application' do
+        expect {
+          parse('apply("foo.example.com") { application test {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'application'/)
       end
 
-      it 'produces an error for capability mapping' do
-        acceptor = validate(parse('apply("foo.example.com") { Foo produces Sql {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+      it 'produces a syntax error for capability mapping' do
+        expect {
+          parse('apply("foo.example.com") { Foo produces Sql {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'produces'/)
       end
 
       it 'produces an error for class expressions' do
@@ -504,9 +504,9 @@ describe "validating 4x" do
       end
 
       it 'produces an error for site definitions' do
-        acceptor = validate(parse('apply("foo.example.com") { site {} }'))
-        expect(acceptor.error_count).to eql(1)
-        expect(acceptor).to have_issue(Puppet::Pops::Issues::EXPRESSION_NOT_SUPPORTED_WHEN_SCRIPTING)
+        expect {
+          parse('apply("foo.example.com") { site {} }')
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at 'site'/)
       end
 
       it 'produces an error for apply() inside apply()' do
@@ -669,6 +669,15 @@ describe "validating 4x" do
     'regexp',
     'pattern',
     'runtime',
+    'init',
+    'object',
+    'sensitive',
+    'semver',
+    'semverrange',
+    'string',
+    'timestamp',
+    'timespan',
+    'typeset',
     ].each do |name|
 
       it "produces an error for 'class #{name}'" do
@@ -693,6 +702,7 @@ describe "validating 4x" do
       source = "type('a', 'b')"
       expect(validate(parse(source))).not_to have_any_issues
     end
+
     it "should allow using the 'type' as the name of a function with no parameters and a block" do
       source = "type() |$x| { $x }"
       expect(validate(parse(source))).not_to have_any_issues
@@ -968,6 +978,18 @@ describe "validating 4x" do
       end
     end
 
+    it "allows a reserved type name" do
+      source = <<-SOURCE
+      class foo {
+        define string() {}
+        foo::string { 'a': }
+      }
+      SOURCE
+
+      acceptor = validate(parse(source, 'path/foo/manifests/init.pp'))
+      expect(acceptor.error_count).to eql(0)
+    end
+
     it "will give multiple errors in one file with multiple issues" do
       source = <<-SOURCE
       class foo {}
@@ -992,17 +1014,10 @@ describe "validating 4x" do
 
   context "capability annotations" do
     ['produces', 'consumes'].each do |word|
-      it "rejects illegal resource types in #{word} clauses" do
-        expect(validate(parse("foo produces Bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "accepts legal resource and capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-        expect(validate(parse("Mod::Foo produces ::Mod2::Bar {}"))).to_not have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
-      end
-
-      it "rejects illegal capability types in #{word} clauses" do
-        expect(validate(parse("Foo produces bar {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_CLASSREF)
+      it "raises a syntax error in #{word} clauses" do
+        expect {
+          parse("foo #{word} Bar {}")
+        }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '#{word}'/)
       end
     end
   end

data/spec/unit/pops/visitor_spec.rb

@@ -39,7 +39,7 @@ describe Puppet::Pops::Visitor do
 
     it "should select method for superclass" do
       duck_processor = DuckProcessor.new
-      expect(duck_processor.hi(42)).to match(/Howdy (?:Fixnum|Integer)/)
+      expect(duck_processor.hi(42)).to match(/Howdy Integer/)
     end
 
     it "should select method for superclass" do

data/spec/unit/property_spec.rb

@@ -5,6 +5,7 @@ Puppet::Type.newtype(:property_test) do
   newparam(:name, isnamevar: true)
 end
 Puppet::Type.type(:property_test).provide(:property_test) do
+  attr_accessor :foo
 end
 
 describe Puppet::Property do

data/spec/unit/provider/nameservice_spec.rb

@@ -3,11 +3,28 @@ require 'puppet/provider/nameservice'
 require 'puppet/etc'
 require 'puppet_spec/character_encoding'
 
+Puppet::Type.newtype(:nameservice_dummytype) do
+  newparam(:name)
+  ensurable
+  newproperty(:foo)
+  newproperty(:bar)
+end
+
+Puppet::Type.type(:nameservice_dummytype).provide(:nameservice_dummyprovider, parent: Puppet::Provider::NameService) do
+  def posixmethod(param)
+    param
+  end
+
+  def modifycmd(param, value)
+    []
+  end
+end
+
 describe Puppet::Provider::NameService do
 
   before :each do
-    described_class.initvars
-    described_class.resource_type = faketype
+    provider.class.initvars
+    provider.class.resource_type = faketype
   end
 
   # These are values getpwent might give you
@@ -41,16 +58,12 @@ describe Puppet::Provider::NameService do
   # The provider sometimes relies on @resource for valid properties so let's
   # create a fake type with properties that match our fake struct.
   let :faketype do
-    Puppet::Type.newtype(:nameservice_dummytype) do
-      newparam(:name)
-      ensurable
-      newproperty(:foo)
-      newproperty(:bar)
-    end
+    Puppet::Type.type(:nameservice_dummytype)
   end
 
   let :provider do
-    described_class.new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
+    Puppet::Type.type(:nameservice_dummytype).provider(:nameservice_dummyprovider)
+      .new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
   end
 
   let :resource do
@@ -91,118 +104,61 @@ describe Puppet::Provider::NameService do
 
   describe "#options" do
     it "should add options for a valid property" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      described_class.options :bar, :key3 => 'val3'
-      expect(described_class.option(:foo, :key1)).to eq('val1')
-      expect(described_class.option(:foo, :key2)).to eq('val2')
-      expect(described_class.option(:bar, :key3)).to eq('val3')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      provider.class.options :bar, :key3 => 'val3'
+      expect(provider.class.option(:foo, :key1)).to eq('val1')
+      expect(provider.class.option(:foo, :key2)).to eq('val2')
+      expect(provider.class.option(:bar, :key3)).to eq('val3')
     end
 
     it "should raise an error for an invalid property" do
-      expect { described_class.options :baz, :key1 => 'val1' }.to raise_error(
+      expect { provider.class.options :baz, :key1 => 'val1' }.to raise_error(
         Puppet::Error, 'baz is not a valid attribute for nameservice_dummytype')
     end
   end
 
   describe "#option" do
     it "should return the correct value" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(described_class.option(:foo, :key2)).to eq('val2')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to eq('val2')
     end
 
     it "should symbolize the name first" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(described_class.option('foo', :key2)).to eq('val2')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(provider.class.option('foo', :key2)).to eq('val2')
     end
 
     it "should return nil if no option has been specified earlier" do
-      expect(described_class.option(:foo, :key2)).to be_nil
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no option for that property has been specified earlier" do
-      described_class.options :bar, :key2 => 'val2'
-      expect(described_class.option(:foo, :key2)).to be_nil
+      provider.class.options :bar, :key2 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no matching key can be found for that property" do
-      described_class.options :foo, :key3 => 'val2'
-      expect(described_class.option(:foo, :key2)).to be_nil
+      provider.class.options :foo, :key3 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
   end
 
   describe "#section" do
     it "should raise an error if resource_type has not been set" do
-      expect(described_class).to receive(:resource_type).and_return(nil)
-      expect { described_class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
+      expect(provider.class).to receive(:resource_type).and_return(nil)
+      expect { provider.class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
     end
 
     # the return values are hard coded so I am using types that actually make
     # use of the nameservice provider
     it "should return pw for users" do
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(described_class.section).to eq('pw')
+      provider.class.resource_type = Puppet::Type.type(:user)
+      expect(provider.class.section).to eq('pw')
     end
 
     it "should return gr for groups" do
-      described_class.resource_type = Puppet::Type.type(:group)
-      expect(described_class.section).to eq('gr')
-    end
-  end
-
-  describe "#listbyname" do
-    it "should be deprecated" do
-      expect(Puppet).to receive(:deprecation_warning).with(/listbyname is deprecated/)
-      described_class.listbyname
-    end
-
-    it "should return a list of users if resource_type is user" do
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      expect(described_class.listbyname).to eq(%w{root foo})
-    end
-
-    context "encoding handling" do
-      described_class.resource_type = Puppet::Type.type(:user)
-
-      # These two tests simulate an environment where there are two users with
-      # the same name on disk, but each name is stored on disk in a different
-      # encoding
-      it "should return names with invalid byte sequences replaced with '?'" do
-        allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
-        expect(invalid_utf_8_jose).to_not be_valid_encoding
-        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
-          described_class.listbyname
-        end
-        expect(result).to eq(['root', 'foo', utf_8_jose, escaped_utf_8_jose])
-      end
-
-      it "should return names in their original encoding/bytes if they would not be valid UTF-8" do
-        allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
-        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
-          described_class.listbyname
-        end
-        expect(result).to eq(['root'.force_encoding(Encoding::UTF_8), 'foo'.force_encoding(Encoding::UTF_8), utf_8_jose, valid_latin1_jose])
-      end
-    end
-
-    it "should return a list of groups if resource_type is group", :unless => Puppet::Util::Platform.windows? do
-      described_class.resource_type = Puppet::Type.type(:group)
-      expect(Puppet::Etc).to receive(:setgrent)
-      allow(Puppet::Etc).to receive(:getgrent).and_return(*groups)
-      expect(Puppet::Etc).to receive(:endgrent)
-      expect(described_class.listbyname).to eq(%w{root bin})
-    end
-
-    it "should yield if a block given" do
-      yield_results = []
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      described_class.listbyname {|x| yield_results << x }
-      expect(yield_results).to eq(%w{root foo})
+      provider.class.resource_type = Puppet::Type.type(:group)
+      expect(provider.class.section).to eq('gr')
     end
   end
 
@@ -213,7 +169,7 @@ describe Puppet::Provider::NameService do
       # encoding
       allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
-        described_class.instances
+        provider.class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -228,7 +184,7 @@ describe Puppet::Provider::NameService do
     it "should have object names in their original encoding/bytes if they would not be valid UTF-8" do
       allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
-        described_class.instances
+        provider.class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -243,40 +199,40 @@ describe Puppet::Provider::NameService do
     it "should pass the Puppet::Etc :canonical_name Struct member to the constructor" do
       users = [ Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
       allow(Etc).to receive(:getpwent).and_return(*users)
-      expect(described_class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
-      described_class.instances
+      expect(provider.class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      provider.class.instances
     end
   end
 
   describe "validate" do
     it "should pass if no check is registered at all" do
-      expect { described_class.validate(:foo, 300) }.to_not raise_error
-      expect { described_class.validate('foo', 300) }.to_not raise_error
+      expect { provider.class.validate(:foo, 300) }.to_not raise_error
+      expect { provider.class.validate('foo', 300) }.to_not raise_error
     end
 
     it "should pass if no check for that property is registered" do
-      described_class.verify(:bar, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 300) }.to_not raise_error
-      expect { described_class.validate('foo', 300) }.to_not raise_error
+      provider.class.verify(:bar, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 300) }.to_not raise_error
+      expect { provider.class.validate('foo', 300) }.to_not raise_error
     end
 
     it "should pass if the value is valid" do
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 100) }.to_not raise_error
-      expect { described_class.validate('foo', 100) }.to_not raise_error
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 100) }.to_not raise_error
+      expect { provider.class.validate('foo', 100) }.to_not raise_error
     end
 
     it "should raise an error if the value is invalid" do
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
-      expect { described_class.validate('foo', 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
+      expect { provider.class.validate('foo', 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
     end
   end
 
   describe "getinfo" do
     before :each do
       # with section=foo we'll call Etc.getfoonam instead of getpwnam or getgrnam
-      allow(described_class).to receive(:section).and_return('foo')
+      allow(provider.class).to receive(:section).and_return('foo')
       resource # initialize the resource so our provider has a @resource instance variable
     end
 
@@ -296,13 +252,13 @@ describe Puppet::Provider::NameService do
     # overriding to UTF-8, in @canonical_name for querying that state on disk
     # again if needed
     it "should use the instance's @canonical_name to query the system" do
-      provider_instance = described_class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
+      provider_instance = provider.class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
       expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'original_foo')
       provider_instance.getinfo(true)
     end
 
     it "should use the instance's name instead of canonical_name if not supplied during instantiation" do
-      provider_instance = described_class.new(:name => 'foo', :ensure => :present)
+      provider_instance = provider.class.new(:name => 'foo', :ensure => :present)
       expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'foo')
       provider_instance.getinfo(true)
     end
@@ -310,16 +266,6 @@ describe Puppet::Provider::NameService do
 
   describe "info2hash" do
     it "should return a hash with all properties" do
-      # we have to have an implementation of posixmethod which has to
-      # convert a propertyname (e.g. comment) into a fieldname of our
-      # Struct (e.g. gecos). I do not want to test posixmethod here so
-      # let's fake an implementation which does not do any translation. We
-      # expect two method invocations because info2hash calls the method
-      # twice if the Struct responds to the propertyname (our fake Struct
-      # provides values for :foo and :bar) TODO: Fix that
-      expect(provider).to receive(:posixmethod).with(:foo).and_return(:foo).twice
-      expect(provider).to receive(:posixmethod).with(:bar).and_return(:bar).twice
-      expect(provider).to receive(:posixmethod).with(:ensure).and_return(:ensure)
       expect(provider.info2hash(fakeetcobject)).to eq({ :foo => 'fooval', :bar => 'barval' })
     end
   end
@@ -330,7 +276,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the munged value otherwise" do
-      described_class.options(:foo, :munge => proc { |x| x*2 })
+      provider.class.options(:foo, :munge => proc { |x| x*2 })
       expect(provider.munge(:foo, 100)).to eq(200)
     end
   end
@@ -341,7 +287,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the unmunged value otherwise" do
-      described_class.options(:foo, :unmunge => proc { |x| x/2 })
+      provider.class.options(:foo, :unmunge => proc { |x| x/2 })
       expect(provider.unmunge(:foo, 200)).to eq(100)
     end
   end
@@ -359,15 +305,13 @@ describe Puppet::Provider::NameService do
   end
 
   describe "get" do
-    before(:each) {described_class.resource_type = faketype }
-
     it "should return the correct getinfo value" do
       expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider.get(:bar)).to eq('barval')
     end
 
     it "should unmunge the value first" do
-      described_class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
       expect(provider).to receive(:getinfo).with(false).and_return(:foo => 200, :bar => 500)
       expect(provider.get(:bar)).to eq(250)
     end
@@ -382,7 +326,7 @@ describe Puppet::Provider::NameService do
   describe "set" do
     before :each do
       resource # initialize resource so our provider has a @resource object
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
     end
 
     it "should raise an error on invalid values" do
@@ -396,7 +340,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should munge the value first" do
-      described_class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
       expect(provider).to receive(:modifycmd).with(:foo, 200).and_return(['/bin/modify', '-f', '200' ])
       expect(provider).to receive(:execute).with(['/bin/modify', '-f', '200'], hash_including(custom_environment: {}))
       provider.set(:foo, 100)