puppet 3.5.0.rc1-x86-mingw32

data/spec/unit/provider/mount_spec.rb

@@ -0,0 +1,165 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/provider/mount'
+
+describe Puppet::Provider::Mount do
+  before :each do
+    @mounter = Object.new
+    @mounter.extend(Puppet::Provider::Mount)
+
+    @name = "/"
+
+    @resource = stub 'resource'
+    @resource.stubs(:[]).with(:name).returns(@name)
+
+    @mounter.stubs(:resource).returns(@resource)
+  end
+
+  describe Puppet::Provider::Mount, " when mounting" do
+
+    before :each do
+      @mounter.stubs(:get).with(:ensure).returns(:mounted)
+    end
+
+    it "should use the 'mountcmd' method to mount" do
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:mountcmd)
+
+      @mounter.mount
+    end
+
+    it "should add the options following '-o' on MacOS if they exist and are not set to :absent" do
+      Facter.expects(:value).with(:kernel).returns 'Darwin'
+      @mounter.stubs(:options).returns("ro")
+      @mounter.expects(:mountcmd).with '-o', 'ro', '/'
+
+      @mounter.mount
+    end
+
+    it "should not explicitly pass mount options on systems other than MacOS" do
+      Facter.expects(:value).with(:kernel).returns 'HP-UX'
+      @mounter.stubs(:options).returns("ro")
+      @mounter.expects(:mountcmd).with '/'
+
+      @mounter.mount
+    end
+
+    it "should specify the filesystem name to the mount command" do
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:mountcmd).with { |*ary| ary[-1] == @name }
+
+      @mounter.mount
+    end
+
+    it "should update the :ensure state to :mounted if it was :unmounted before" do
+      @mounter.expects(:mountcmd)
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:get).with(:ensure).returns(:unmounted)
+      @mounter.expects(:set).with(:ensure => :mounted)
+      @mounter.mount
+    end
+
+    it "should update the :ensure state to :ghost if it was :absent before" do
+      @mounter.expects(:mountcmd)
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:get).with(:ensure).returns(:absent)
+      @mounter.expects(:set).with(:ensure => :ghost)
+      @mounter.mount
+    end
+
+  end
+
+  describe Puppet::Provider::Mount, " when remounting" do
+
+    it "should use '-o remount' if the resource specifies it supports remounting" do
+      @mounter.stubs(:info)
+      @resource.stubs(:[]).with(:remounts).returns(:true)
+      @mounter.expects(:mountcmd).with("-o", "remount", @name)
+      @mounter.remount
+    end
+
+    it "should mount with '-o update' on OpenBSD" do
+      @mounter.stubs(:info)
+      @mounter.stubs(:options)
+      @resource.stubs(:[]).with(:remounts).returns(false)
+      Facter.expects(:value).with(:operatingsystem).returns 'OpenBSD'
+      @mounter.expects(:mountcmd).with("-o", "update", @name)
+      @mounter.remount
+    end
+
+    it "should unmount and mount if the resource does not specify it supports remounting" do
+      @mounter.stubs(:info)
+      @mounter.stubs(:options)
+      @resource.stubs(:[]).with(:remounts).returns(false)
+      Facter.expects(:value).with(:operatingsystem).returns 'AIX'
+      @mounter.expects(:mount)
+      @mounter.expects(:unmount)
+      @mounter.remount
+    end
+
+    it "should log that it is remounting" do
+      @resource.stubs(:[]).with(:remounts).returns(:true)
+      @mounter.stubs(:mountcmd)
+      @mounter.expects(:info).with("Remounting")
+      @mounter.remount
+    end
+  end
+
+  describe Puppet::Provider::Mount, " when unmounting" do
+
+    before :each do
+      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+    end
+
+    it "should call the :umount command with the resource name" do
+      @mounter.expects(:umount).with(@name)
+      @mounter.unmount
+    end
+
+    it "should update the :ensure state to :absent if it was :ghost before" do
+      @mounter.expects(:umount).with(@name).returns true
+      @mounter.expects(:get).with(:ensure).returns(:ghost)
+      @mounter.expects(:set).with(:ensure => :absent)
+      @mounter.unmount
+    end
+
+    it "should update the :ensure state to :unmounted if it was :mounted before" do
+      @mounter.expects(:umount).with(@name).returns true
+      @mounter.expects(:get).with(:ensure).returns(:mounted)
+      @mounter.expects(:set).with(:ensure => :unmounted)
+      @mounter.unmount
+    end
+
+  end
+
+  describe Puppet::Provider::Mount, " when determining if it is mounted" do
+
+    it "should query the property_hash" do
+      @mounter.expects(:get).with(:ensure).returns(:mounted)
+      @mounter.mounted?
+    end
+
+    it "should return true if prefetched value is :mounted" do
+      @mounter.stubs(:get).with(:ensure).returns(:mounted)
+      @mounter.mounted? == true
+    end
+
+    it "should return true if prefetched value is :ghost" do
+      @mounter.stubs(:get).with(:ensure).returns(:ghost)
+      @mounter.mounted? == true
+    end
+
+    it "should return false if prefetched value is :absent" do
+      @mounter.stubs(:get).with(:ensure).returns(:absent)
+      @mounter.mounted? == false
+    end
+
+    it "should return false if prefetched value is :unmounted" do
+      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+      @mounter.mounted? == false
+    end
+
+  end
+
+end

data/spec/unit/provider/naginator_spec.rb

@@ -0,0 +1,65 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+require 'puppet/provider/naginator'
+
+describe Puppet::Provider::Naginator do
+  before do
+    @resource_type = stub 'resource_type', :name => :nagios_test
+    @class = Class.new(Puppet::Provider::Naginator)
+
+    @class.stubs(:resource_type).returns @resource_type
+  end
+
+  it "should be able to look up the associated Nagios type" do
+    nagios_type = mock "nagios_type"
+    nagios_type.stubs :attr_accessor
+    Nagios::Base.expects(:type).with(:test).returns nagios_type
+
+    @class.nagios_type.should equal(nagios_type)
+  end
+
+  it "should use the Nagios type to determine whether an attribute is valid" do
+    nagios_type = mock "nagios_type"
+    nagios_type.stubs :attr_accessor
+    Nagios::Base.expects(:type).with(:test).returns nagios_type
+
+    nagios_type.expects(:parameters).returns [:foo, :bar]
+
+    @class.valid_attr?(:test, :foo).should be_true
+  end
+
+  it "should use Naginator to parse configuration snippets" do
+    parser = mock 'parser'
+    parser.expects(:parse).with("my text").returns "my instances"
+    Nagios::Parser.expects(:new).returns(parser)
+
+    @class.parse("my text").should == "my instances"
+  end
+
+  it "should join Nagios::Base records with '\\n' when asked to convert them to text" do
+    @class.expects(:header).returns "myheader\n"
+
+    @class.to_file([:one, :two]).should == "myheader\none\ntwo"
+  end
+
+  it "should be able to prefetch instance from configuration files" do
+    @class.should respond_to(:prefetch)
+  end
+
+  it "should be able to generate a list of instances" do
+    @class.should respond_to(:instances)
+  end
+
+  it "should never skip records" do
+    @class.should_not be_skip_record("foo")
+  end
+end
+
+describe Nagios::Base do
+  it "should not turn set parameters into arrays #17871" do
+    obj = Nagios::Base.create('host')
+    obj.host_name = "my_hostname"
+    obj.host_name.should == "my_hostname"
+  end
+end

data/spec/unit/provider/nameservice/directoryservice_spec.rb

@@ -0,0 +1,189 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+# We use this as a reasonable way to obtain all the support infrastructure.
+[:group].each do |type_for_this_round|
+  provider_class = Puppet::Type.type(type_for_this_round).provider(:directoryservice)
+
+  describe provider_class do
+    before do
+      @resource = stub("resource")
+      @provider = provider_class.new(@resource)
+    end
+
+    it "[#6009] should handle nested arrays of members" do
+      current = ["foo", "bar", "baz"]
+      desired = ["foo", ["quux"], "qorp"]
+      group   = 'example'
+
+      @resource.stubs(:[]).with(:name).returns(group)
+      @resource.stubs(:[]).with(:auth_membership).returns(true)
+      @provider.instance_variable_set(:@property_value_cache_hash,
+                                      { :members => current })
+
+      %w{bar baz}.each do |del|
+        @provider.expects(:execute).once.
+          with([:dseditgroup, '-o', 'edit', '-n', '.', '-d', del, group])
+      end
+
+      %w{quux qorp}.each do |add|
+        @provider.expects(:execute).once.
+          with([:dseditgroup, '-o', 'edit', '-n', '.', '-a', add, group])
+      end
+
+      expect { @provider.set(:members, desired) }.to_not raise_error
+    end
+  end
+end
+
+describe 'DirectoryService.single_report' do
+  it 'should fail on OS X < 10.5' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+
+    expect {
+      Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+    }.to raise_error(RuntimeError, "Puppet does not support OS X versions < 10.5")
+  end
+
+  it 'should use plist data on >= 10.5' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+    Puppet::Provider::NameService::DirectoryService.stubs(:list_all_present).returns(
+      ['root', 'user1', 'user2', 'resource_name']
+    )
+    Puppet::Provider::NameService::DirectoryService.stubs(:generate_attribute_hash)
+    Puppet::Provider::NameService::DirectoryService.stubs(:execute)
+    Puppet::Provider::NameService::DirectoryService.expects(:parse_dscl_plist_data)
+
+    Puppet::Provider::NameService::DirectoryService.single_report('resource_name')
+  end
+end
+
+describe 'DirectoryService.get_exec_preamble' do
+  it 'should fail on OS X < 10.5' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.4")
+
+    expect {
+      Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list')
+    }.to raise_error(RuntimeError, "Puppet does not support OS X versions < 10.5")
+  end
+
+  it 'should use plist data on >= 10.5' do
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_macosx_version_major).returns("10.5")
+    Puppet::Provider::NameService::DirectoryService.stubs(:get_ds_path).returns('Users')
+
+    Puppet::Provider::NameService::DirectoryService.get_exec_preamble('-list').should include("-plist")
+  end
+end
+
+describe 'DirectoryService password behavior' do
+  # The below is a binary plist containing a ShadowHashData key which CONTAINS
+  # another binary plist. The nested binary plist contains a 'SALTED-SHA512'
+  # key that contains a base64 encoded salted-SHA512 password hash...
+  let (:binary_plist) { "bplist00\324\001\002\003\004\005\006\a\bXCRAM-MD5RNT]SALTED-SHA512[RECOVERABLEO\020 \231k2\3360\200GI\201\355J\216\202\215y\243\001\206J\300\363\032\031\022\006\2359\024\257\217<\361O\020\020F\353\at\377\277\226\276c\306\254\031\037J(\235O\020D\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245O\021\002\000k\024\221\270x\353\001\237\346D}\377?\265]\356+\243\v[\350\316a\340h\376<\322\266\327\016\306n\272r\t\212A\253L\216\214\205\016\241 [\360/\335\002#\\A\372\241a\261\346\346\\\251\330\312\365\016\n\341\017\016\225&;\322\\\004*\ru\316\372\a \362?8\031\247\231\030\030\267\315\023\v\343{@\227\301s\372h\212\000a\244&\231\366\nt\277\2036,\027bZ+\223W\212g\333`\264\331N\306\307\362\257(^~ b\262\247&\231\261t\341\231%\244\247\203eOt\365\271\201\273\330\350\363C^A\327F\214!\217hgf\e\320k\260n\315u~\336\371M\t\235k\230S\375\311\303\240\351\037d\273\321y\335=K\016`_\317\230\2612_\023K\036\350\v\232\323Y\310\317_\035\227%\237\v\340\023\016\243\233\025\306:\227\351\370\364x\234\231\266\367\016w\275\333-\351\210}\375x\034\262\272kRuHa\362T/F!\347B\231O`K\304\037'k$$\245h)e\363\365mT\b\317\\2\361\026\351\254\375Jl1~\r\371\267\352\2322I\341\272\376\243^Un\266E7\230[VocUJ\220N\2116D/\025f=\213\314\325\vG}\311\360\377DT\307m\261&\263\340\272\243_\020\271rG^BW\210\030l\344\0324\335\233\300\023\272\225Im\330\n\227*Yv[\006\315\330y'\a\321\373\273A\240\305F{S\246I#/\355\2425\031\031GGF\270y\n\331\004\023G@\331\000\361\343\350\264$\032\355_\210y\000\205\342\375\212q\024\004\026W:\205 \363v?\035\270L-\270=\022\323\2003\v\336\277\t\237\356\374\n\267n\003\367\342\330;\371S\326\016`B6@Njm>\240\021%\336\345\002(P\204Yn\3279l\0228\264\254\304\2528t\372h\217\347sA\314\345\245\337)]\000\b\000\021\000\032\000\035\000+\0007\000Z\000m\000\264\000\000\000\000\000\000\002\001\000\000\000\000\000\000\000\t\000\000\000\000\000\000\000\000\000\000\000\000\000\000\002\270" }
+
+  # The below is a base64 encoded salted-SHA512 password hash.
+  let (:pw_string) { "\335\006{\3744g@\377z\204\322\r\332t\021\330\n\003\246K\223\356\034!P\261\305t\035\346\352p\206\003n\247MMA\310\301Z<\366\246\023\0161W3\340\357\000\317T\t\301\311+\204\246L7\276\370\320*\245" }
+
+  # The below is a salted-SHA512 password hash in hex.
+  let (:sha512_hash) { 'dd067bfc346740ff7a84d20dda7411d80a03a64b93ee1c2150b1c5741de6ea7086036ea74d4d41c8c15a3cf6a6130e315733e0ef00cf5409c1c92b84a64c37bef8d02aa5' }
+
+  let :plist_path do
+    '/var/db/dslocal/nodes/Default/users/jeff.plist'
+  end
+
+  let :ds_provider do
+    Puppet::Provider::NameService::DirectoryService
+  end
+
+  let :shadow_hash_data do
+    {'ShadowHashData' => [StringIO.new(binary_plist)]}
+  end
+
+  subject do
+    Puppet::Provider::NameService::DirectoryService
+  end
+
+  before :each do
+    subject.expects(:get_macosx_version_major).returns("10.7")
+  end
+
+  it 'should execute convert_binary_to_xml once when getting the password on >= 10.7' do
+    subject.expects(:convert_binary_to_xml).returns({'SALTED-SHA512' => StringIO.new(pw_string)})
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
+    Plist.expects(:parse_xml).returns(shadow_hash_data)
+    # On Mac OS X 10.7 we first need to convert to xml when reading the password
+    subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
+    subject.get_password('uid', 'jeff')
+  end
+
+  it 'should fail if a salted-SHA512 password hash is not passed in >= 10.7' do
+    expect {
+      subject.set_password('jeff', 'uid', 'badpassword')
+    }.to raise_error(RuntimeError, /OS X 10.7 requires a Salted SHA512 hash password of 136 characters./)
+  end
+
+  it 'should convert xml-to-binary and binary-to-xml when setting the pw on >= 10.7' do
+    subject.expects(:convert_binary_to_xml).returns({'SALTED-SHA512' => StringIO.new(pw_string)})
+    subject.expects(:convert_xml_to_binary).returns(binary_plist)
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
+    Plist.expects(:parse_xml).returns(shadow_hash_data)
+    # On Mac OS X 10.7 we first need to convert to xml
+    subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
+    # And again back to a binary plist or DirectoryService will complain
+    subject.expects(:plutil).with('-convert', 'binary1', plist_path)
+    Plist::Emit.expects(:save_plist).with(shadow_hash_data, plist_path)
+    subject.set_password('jeff', 'uid', sha512_hash)
+  end
+
+  it '[#13686] should handle an empty ShadowHashData field in the users plist' do
+    subject.expects(:convert_xml_to_binary).returns(binary_plist)
+    Puppet::FileSystem.expects(:exist?).with(plist_path).once.returns(true)
+    Plist.expects(:parse_xml).returns({'ShadowHashData' => nil})
+    subject.expects(:plutil).with('-convert', 'xml1', '-o', '/dev/stdout', plist_path)
+    subject.expects(:plutil).with('-convert', 'binary1', plist_path)
+    Plist::Emit.expects(:save_plist)
+    subject.set_password('jeff', 'uid', sha512_hash)
+  end
+end
+
+describe '(#4855) directoryservice group resource failure' do
+  let :provider_class do
+    Puppet::Type.type(:group).provider(:directoryservice)
+  end
+
+  let :group_members do
+    ['root','jeff']
+  end
+
+  let :user_account do
+    ['root']
+  end
+
+  let :stub_resource do
+    stub('resource')
+  end
+
+  subject do
+    provider_class.new(stub_resource)
+  end
+
+  before :each do
+    @resource = stub("resource")
+    @provider = provider_class.new(@resource)
+  end
+
+  it 'should delete a group member if the user does not exist' do
+    stub_resource.stubs(:[]).with(:name).returns('fake_group')
+    stub_resource.stubs(:name).returns('fake_group')
+    subject.expects(:execute).with([:dseditgroup, '-o', 'edit', '-n', '.',
+                                   '-d', 'jeff',
+                                   'fake_group']).raises(Puppet::ExecutionFailure,
+                                   'it broke')
+    subject.expects(:execute).with([:dscl, '.', '-delete',
+                                   '/Groups/fake_group', 'GroupMembership',
+                                   'jeff'])
+    subject.remove_unwanted_members(group_members, user_account)
+  end
+end
+

data/spec/unit/provider/nameservice_spec.rb

@@ -0,0 +1,304 @@
+#! /usr/bin/env ruby
+
+require 'spec_helper'
+require 'puppet/provider/nameservice'
+require 'etc'
+
+describe Puppet::Provider::NameService do
+
+  before :each do
+    described_class.initvars
+    described_class.resource_type = faketype
+  end
+
+  # These are values getpwent might give you
+  let :users do
+    [
+      Struct::Passwd.new('root', 'x', 0, 0),
+      Struct::Passwd.new('foo', 'x', 1000, 2000),
+      nil
+    ]
+  end
+
+  # These are values getgrent might give you
+  let :groups do
+    [
+      Struct::Group.new('root', 'x', 0, %w{root}),
+      Struct::Group.new('bin', 'x', 1, %w{root bin daemon}),
+      nil
+    ]
+  end
+
+  # A fake struct besides Struct::Group and Struct::Passwd
+  let :fakestruct do
+    Struct.new(:foo, :bar)
+  end
+
+  # A fake value get<foo>ent might return
+  let :fakeetcobject do
+    fakestruct.new('fooval', 'barval')
+  end
+
+  # 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
+  end
+
+  let :provider do
+    described_class.new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
+  end
+
+  let :resource do
+    resource = faketype.new(:name => 'bob', :ensure => :present)
+    resource.provider = provider
+    resource
+  end
+
+  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'
+      described_class.option(:foo, :key1).should == 'val1'
+      described_class.option(:foo, :key2).should == 'val2'
+      described_class.option(:bar, :key3).should == 'val3'
+    end
+
+    it "should raise an error for an invalid property" do
+      expect { described_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'
+      described_class.option(:foo, :key2).should == 'val2'
+    end
+
+    it "should symbolize the name first" do
+      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      described_class.option('foo', :key2).should == 'val2'
+    end
+
+    it "should return nil if no option has been specified earlier" do
+      described_class.option(:foo, :key2).should be_nil
+    end
+
+    it "should return nil if no option for that property has been specified earlier" do
+      described_class.options :bar, :key2 => 'val2'
+      described_class.option(:foo, :key2).should be_nil
+    end
+
+    it "should return nil if no matching key can be found for that property" do
+      described_class.options :foo, :key3 => 'val2'
+      described_class.option(:foo, :key2).should be_nil
+    end
+  end
+
+  describe "#section" do
+    it "should raise an error if resource_type has not been set" do
+      described_class.expects(:resource_type).returns nil
+      expect { described_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)
+      described_class.section.should == 'pw'
+    end
+
+    it "should return gr for groups" do
+      described_class.resource_type = Puppet::Type.type(:group)
+      described_class.section.should == 'gr'
+    end
+  end
+
+  describe "#listbyname" do
+    it "should return a list of users if resource_type is user" do
+      described_class.resource_type = Puppet::Type.type(:user)
+      Etc.expects(:setpwent)
+      Etc.stubs(:getpwent).returns *users
+      Etc.expects(:endpwent)
+      described_class.listbyname.should == %w{root foo}
+    end
+
+    it "should return a list of groups if resource_type is group", :unless => Puppet.features.microsoft_windows? do
+      described_class.resource_type = Puppet::Type.type(:group)
+      Etc.expects(:setgrent)
+      Etc.stubs(:getgrent).returns *groups
+      Etc.expects(:endgrent)
+      described_class.listbyname.should == %w{root bin}
+    end
+
+    it "should yield if a block given" do
+      yield_results = []
+      described_class.resource_type = Puppet::Type.type(:user)
+      Etc.expects(:setpwent)
+      Etc.stubs(:getpwent).returns *users
+      Etc.expects(:endpwent)
+      described_class.listbyname {|x| yield_results << x }
+      yield_results.should == %w{root foo}
+    end
+  end
+
+  describe "instances" do
+    it "should return a list of objects based on listbyname" do
+      described_class.expects(:listbyname).multiple_yields 'root', 'foo', 'nobody'
+      described_class.instances.map(&:name).should == %w{root foo nobody}
+    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
+    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
+    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
+    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')
+    end
+  end
+
+  describe "getinfo" do
+    before :each do
+      # with section=foo we'll call Etc.getfoonam instead of getpwnam or getgrnam
+      described_class.stubs(:section).returns 'foo'
+      resource # initialize the resource so our provider has a @resource instance variable
+    end
+
+    it "should return a hash if we can retrieve something" do
+      Etc.expects(:send).with(:getfoonam, 'bob').returns fakeetcobject
+      provider.expects(:info2hash).with(fakeetcobject).returns(:foo => 'fooval', :bar => 'barval')
+      provider.getinfo(true).should == {:foo => 'fooval', :bar => 'barval'}
+    end
+
+    it "should return nil if we cannot retrieve anything" do
+      Etc.expects(:send).with(:getfoonam, 'bob').raises(ArgumentError, "can't find bob")
+      provider.expects(:info2hash).never
+      provider.getinfo(true).should be_nil
+    end
+  end
+
+  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
+      provider.expects(:posixmethod).with(:foo).returns(:foo).twice
+      provider.expects(:posixmethod).with(:bar).returns(:bar).twice
+      provider.expects(:posixmethod).with(:ensure).returns :ensure
+      provider.info2hash(fakeetcobject).should == { :foo => 'fooval', :bar => 'barval' }
+    end
+  end
+
+  describe "munge" do
+    it "should return the input value if no munge method has be defined" do
+      provider.munge(:foo, 100).should == 100
+    end
+
+    it "should return the munged value otherwise" do
+      described_class.options(:foo, :munge => proc { |x| x*2 })
+      provider.munge(:foo, 100).should == 200
+    end
+  end
+
+  describe "unmunge" do
+    it "should return the input value if no unmunge method has been defined" do
+      provider.unmunge(:foo, 200).should == 200
+    end
+
+    it "should return the unmunged value otherwise" do
+      described_class.options(:foo, :unmunge => proc { |x| x/2 })
+      provider.unmunge(:foo, 200).should == 100
+    end
+  end
+
+
+  describe "exists?" do
+    it "should return true if we can retrieve anything" do
+      provider.expects(:getinfo).with(true).returns(:foo => 'fooval', :bar => 'barval')
+      provider.should be_exists
+    end
+    it "should return false if we cannot retrieve anything" do
+      provider.expects(:getinfo).with(true).returns nil
+      provider.should_not be_exists
+    end
+  end
+
+  describe "get" do
+    before(:each) {described_class.resource_type = faketype }
+
+    it "should return the correct getinfo value" do
+      provider.expects(:getinfo).with(false).returns(:foo => 'fooval', :bar => 'barval')
+      provider.get(:bar).should == 'barval'
+    end
+
+    it "should unmunge the value first" do
+      described_class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.expects(:getinfo).with(false).returns(:foo => 200, :bar => 500)
+      provider.get(:bar).should == 250
+    end
+
+    it "should return nil if getinfo cannot retrieve the value" do
+      provider.expects(:getinfo).with(false).returns(:foo => 'fooval', :bar => 'barval')
+      provider.get(:no_such_key).should be_nil
+    end
+
+  end
+
+  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 }
+    end
+
+    it "should raise an error on invalid values" do
+      expect { provider.set(:foo, 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
+    end
+
+    it "should execute the modify command on valid values" do
+      provider.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
+      provider.expects(:execute).with ['/bin/modify', '-f', '100']
+      provider.set(:foo, 100)
+    end
+
+    it "should munge the value first" do
+      described_class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.expects(:modifycmd).with(:foo, 200).returns ['/bin/modify', '-f', '200' ]
+      provider.expects(:execute).with ['/bin/modify', '-f', '200']
+      provider.set(:foo, 100)
+    end
+
+    it "should fail if the modify command fails" do
+      provider.expects(:modifycmd).with(:foo, 100).returns ['/bin/modify', '-f', '100' ]
+      provider.expects(:execute).with(['/bin/modify', '-f', '100']).raises(Puppet::ExecutionFailure, "Execution of '/bin/modify' returned 1: some_failure")
+      expect { provider.set(:foo, 100) }.to raise_error Puppet::Error, /Could not set foo/
+    end
+  end
+
+end