puppet 4.0.0 → 4.5.0

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

@@ -32,25 +32,19 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
   describe "group type :members property helpers" do
 
-    let(:user1) { stub(:account => 'user1', :domain => '.', :to_s => 'user1sid') }
-    let(:user2) { stub(:account => 'user2', :domain => '.', :to_s => 'user2sid') }
-    let(:user3) { stub(:account => 'user3', :domain => '.', :to_s => 'user3sid') }
+    let(:user1) { stub(:account => 'user1', :domain => '.', :sid => 'user1sid') }
+    let(:user2) { stub(:account => 'user2', :domain => '.', :sid => 'user2sid') }
+    let(:user3) { stub(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+    let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user1').returns(user1)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user2').returns(user2)
       Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('user3').returns(user3)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with(invalid_user).returns(nil)
     end
 
     describe "#members_insync?" do
-      it "should return false when current is nil" do
-        expect(provider.members_insync?(nil, ['user2'])).to be_falsey
-      end
-
-      it "should return false when should is nil" do
-        expect(provider.members_insync?(['user1'], nil)).to be_falsey
-      end
-
       it "should return true for same lists of members" do
         expect(provider.members_insync?(['user1', 'user2'], ['user1', 'user2'])).to be_truthy
       end
@@ -63,11 +57,31 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         expect(provider.members_insync?(['user1', 'user2', 'user2'], ['user2', 'user1', 'user1'])).to be_truthy
       end
 
+      it "should return true when current and should members are empty lists" do
+        expect(provider.members_insync?([], [])).to be_truthy
+      end
+
+      # invalid scenarios
+      #it "should return true when current and should members are nil lists" do
+      #it "should return true when current members is nil and should members is empty" do
+
+      it "should return true when current members is empty and should members is nil" do
+        expect(provider.members_insync?([], nil)).to be_truthy
+      end
+
       context "when auth_membership => true" do
         before :each do
           resource[:auth_membership] = true
         end
 
+        it "should return false when current is nil" do
+          expect(provider.members_insync?(nil, ['user2'])).to be_falsey
+        end
+
+        it "should return false when should is nil" do
+          expect(provider.members_insync?(['user1'], nil)).to be_falsey
+        end
+
         it "should return false when current contains different users than should" do
           expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
         end
@@ -83,6 +97,10 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         it "should return false when should user(s) are not the only items in the current" do
           expect(provider.members_insync?(['user1', 'user2'], ['user1'])).to be_falsey
         end
+
+        it "should return false when current user(s) is not empty and should is an empty list" do
+          expect(provider.members_insync?(['user1','user2'], [])).to be_falsey
+        end
       end
 
       context "when auth_membership => false" do
@@ -91,6 +109,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
           resource[:auth_membership] = false
         end
 
+        it "should return false when current is nil" do
+          expect(provider.members_insync?(nil, ['user2'])).to be_falsey
+        end
+
+        it "should return true when should is nil" do
+          expect(provider.members_insync?(['user1'], nil)).to be_truthy
+        end
+
         it "should return false when current contains different users than should" do
           expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
         end
@@ -105,7 +131,11 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
         it "should return true when current user(s) contains at least the should list" do
           expect(provider.members_insync?(['user1','user2'], ['user1'])).to be_truthy
-          end
+        end
+
+        it "should return true when current user(s) is not empty and should is an empty list" do
+          expect(provider.members_insync?(['user1','user2'], [])).to be_truthy
+        end
 
         it "should return true when current user(s) contains at least the should list, even unordered" do
           expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
@@ -129,6 +159,12 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       it "should return a user string like DOMAIN\\USER,DOMAIN2\\USER2" do
         expect(provider.members_to_s(['user1', 'user2'])).to eq('.\user1,.\user2')
       end
+      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
+        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+      end
+      it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
+        expect(provider.members_to_s([invalid_user])).to eq("#{invalid_user}")
+      end
     end
   end
 
@@ -147,9 +183,9 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       provider.group.stubs(:members).returns ['user1', 'user2']
 
       member_sids = [
-        stub(:account => 'user1', :domain => 'testcomputername'),
-        stub(:account => 'user2', :domain => 'testcomputername'),
-        stub(:account => 'user3', :domain => 'testcomputername'),
+        stub(:account => 'user1', :domain => 'testcomputername', :sid => 1),
+        stub(:account => 'user2', :domain => 'testcomputername', :sid => 2),
+        stub(:account => 'user3', :domain => 'testcomputername', :sid => 3),
       ]
 
       provider.group.stubs(:member_sids).returns(member_sids[0..1])
@@ -185,6 +221,18 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         /Cannot create group if user 'testers' exists./ )
     end
 
+    it "should fail with an actionable message when trying to create an active directory group" do
+      resource[:name] = 'DOMAIN\testdomaingroup'
+      Puppet::Util::Windows::ADSI::User.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      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 groups/
+                                   )
+    end
+
     it 'should commit a newly created group' do
       provider.group.expects( :commit )
 
@@ -193,8 +241,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
   end
 
   it "should be able to test whether a group exists" do
-    Puppet::Util::Windows::ADSI.stubs(:sid_uri_safe).returns(nil)
-    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection')
+    Puppet::Util::Windows::SID.stubs(:name_to_sid_object).returns(nil)
+    Puppet::Util::Windows::ADSI.stubs(:connect).returns stub('connection', :Class => 'Group')
     expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
@@ -207,6 +255,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     provider.delete
   end
 
+  it 'should not run commit on a deleted group' do
+    connection.expects(:Delete).with('group', 'testers')
+    connection.expects(:SetInfo).never
+
+    provider.delete
+    provider.flush
+  end
+
   it "should report the group's SID as gid" do
     Puppet::Util::Windows::SID.expects(:name_to_sid).with('testers').returns('S-1-5-32-547')
     expect(provider.gid).to eq('S-1-5-32-547')

data/spec/unit/provider/macauthorization_spec.rb

@@ -6,7 +6,9 @@
 require 'spec_helper'
 
 require 'puppet'
-require 'plist'
+
+module Puppet::Util::Plist
+end
 
 provider_class = Puppet::Type.type(:macauthorization).provider(:macauthorization)
 
@@ -26,7 +28,8 @@ describe provider_class do
     authdb["rights"] = { "fooright" => "foo" }
 
     # Stub out Plist::parse_xml
-    Plist.stubs(:parse_xml).returns(authdb)
+    Puppet::Util::Plist.stubs(:parse_plist).returns(authdb)
+    Puppet::Util::Plist.stubs(:write_plist_file)
 
     # A catch all; no parameters set
     @resource.stubs(:[]).returns(nil)

data/spec/unit/provider/mount/parsed_spec.rb

@@ -8,6 +8,9 @@ require 'shared_behaviours/all_parsedfile_providers'
 # restore Solaris spec tests.
 
 describe Puppet::Type.type(:mount).provider(:parsed), :unless => Puppet.features.microsoft_windows? do
+  before :each do
+    Facter.clear
+  end
 
   let :vfstab_sample do
     "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
@@ -26,6 +29,11 @@ describe Puppet::Type.type(:mount).provider(:parsed), :unless => Puppet.features
     end
   end
 
+  it "should default to /etc/vfstab on Solaris" do
+    pending "This test only works on AIX" unless Facter.value(:osfamily) == 'AIX'
+    expect(described_class.default_target).to eq('/etc/filesystems')
+  end
+
   it "should default to /etc/fstab on anything else" do
     if Facter.value(:osfamily) == 'Solaris'
       skip("This test only does not work on Solaris")
@@ -171,10 +179,14 @@ FSTAB
       described_class.stubs(:mountcmd).returns(File.read(my_fixture('aix.mount')))
       mounts = described_class.mountinstances
       expect(mounts[0]).to eq({ :name => '/', :mounted => :yes })
-      expect(mounts[1]).to eq({ :name => '/tmp', :mounted => :yes })
-      expect(mounts[2]).to eq({ :name => '/home', :mounted => :yes })
-      expect(mounts[3]).to eq({ :name => '/usr', :mounted => :yes })
-      expect(mounts[4]).to eq({ :name => '/usr/code', :mounted => :yes })
+      expect(mounts[1]).to eq({ :name => '/usr', :mounted => :yes })
+      expect(mounts[2]).to eq({ :name => '/var', :mounted => :yes })
+      expect(mounts[3]).to eq({ :name => '/tmp', :mounted => :yes })
+      expect(mounts[4]).to eq({ :name => '/home', :mounted => :yes })
+      expect(mounts[5]).to eq({ :name => '/admin', :mounted => :yes })
+      expect(mounts[6]).to eq({ :name => '/proc', :mounted => :yes })
+      expect(mounts[7]).to eq({ :name => '/opt', :mounted => :yes })
+      expect(mounts[8]).to eq({ :name => '/srv/aix', :mounted => :yes })
     end
 
     it "should raise an error if a line is not understandable" do
@@ -184,7 +196,21 @@ FSTAB
 
   end
 
-  it "should support AIX's paragraph based /etc/filesystems"
+  it "should support AIX's paragraph based /etc/filesystems" do
+    pending "This test only works on AIX" unless Facter.value(:osfamily) == 'AIX'
+    Facter.stubs(:value).with(:osfamily).returns 'AIX'
+    described_class.stubs(:default_target).returns my_fixture('aix.filesystems')
+    described_class.stubs(:mountcmd).returns File.read(my_fixture('aix.mount'))
+    instances = described_class.instances
+    expect(instances[0].name).to eq("/")
+    expect(instances[0].device).to eq("/dev/hd4")
+    expect(instances[0].fstype).to eq("jfs2")
+    expect(instances[0].options).to eq("check=false,free=true,log=NULL,mount=automatic,quota=no,type=bootfs,vol=root")
+    expect(instances[11].name).to eq("/srv/aix")
+    expect(instances[11].device).to eq("mynode")
+    expect(instances[11].fstype).to eq("nfs")
+    expect(instances[11].options).to eq("vers=2,account=false,log=NULL,mount=true")
+  end
 
   my_fixtures('*.fstab').each do |fstab|
     platform = File.basename(fstab, '.fstab')

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

@@ -1,6 +1,9 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
+module Puppet::Util::Plist
+end
+
 # 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)
@@ -79,19 +82,17 @@ describe 'DirectoryService password behavior' do
   end
 
   let :shadow_hash_data do
-    {'ShadowHashData' => [StringIO.new(binary_plist)]}
+    {'ShadowHashData' => [binary_plist]}
   end
 
   subject do
     Puppet::Provider::NameService::DirectoryService
   end
 
-  it 'should execute convert_binary_to_xml once when getting the password' do
-    subject.expects(:convert_binary_to_xml).returns({'SALTED-SHA512' => StringIO.new(pw_string)})
+  it 'should execute convert_binary_to_hash once when getting the password' do
+    subject.expects(:convert_binary_to_hash).returns({'SALTED-SHA512' => 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)
+    Puppet::Util::Plist.expects(:read_plist_file).returns(shadow_hash_data)
     subject.get_password('uid', 'jeff')
   end
 
@@ -102,25 +103,19 @@ describe 'DirectoryService password behavior' do
   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)
+    subject.expects(:convert_binary_to_hash).returns({'SALTED-SHA512' => pw_string})
+    subject.expects(:convert_hash_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)
+    Puppet::Util::Plist.expects(:read_plist_file).returns(shadow_hash_data)
+    Puppet::Util::Plist.expects(:write_plist_file).with(shadow_hash_data, plist_path, :binary)
     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)
+    subject.expects(:convert_hash_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)
+    Puppet::Util::Plist.expects(:read_plist_file).returns({'ShadowHashData' => nil})
+    Puppet::Util::Plist.expects(:write_plist_file)
     subject.set_password('jeff', 'uid', sha512_hash)
   end
 end

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

@@ -7,8 +7,7 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
 
   describe "when installing an appdmg" do
     let(:fake_mountpoint) { "/tmp/dmg.foo" }
-    let(:empty_hdiutil_plist) { Plist::Emit.dump({}) }
-    let(:fake_hdiutil_plist) { Plist::Emit.dump({"system-entities" => [{"mount-point" => fake_mountpoint}]}) }
+    let(:fake_hdiutil_plist) { {"system-entities" => [{"mount-point" => fake_mountpoint}]} }
 
     before do
       fh = mock 'filehandle'
@@ -32,7 +31,8 @@ describe Puppet::Type.type(:package).provider(:appdmg) do
         described_class.expects(:curl).with do |*args|
           args[0] == "-o" && args[1].include?(tmpdir) && ! args.include?("-k")
         end
-        described_class.stubs(:hdiutil).returns fake_hdiutil_plist
+        described_class.stubs(:hdiutil).returns 'a plist'
+        Puppet::Util::Plist.expects(:parse_plist).with('a plist').returns fake_hdiutil_plist
         described_class.expects(:installapp)
 
         provider.install

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

@@ -19,6 +19,11 @@ describe provider_class do
     provider
   end
 
+  it "should be the default provider on :osfamily => Debian" do
+    Facter.expects(:value).with(:osfamily).returns("Debian")
+    expect(described_class.default?).to be_truthy
+  end
+
   it "should be versionable" do
     expect(provider_class).to be_versionable
   end

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

@@ -24,9 +24,9 @@ describe Puppet::Type.type(:package).provider(:aptrpm) do
       pkg.provider.expects(:rpm).with(*args)
     end
 
-    it "should report absent packages" do
+    it "should report purged packages" do
       rpm.raises(Puppet::ExecutionFailure, "couldn't find rpm")
-      expect(pkg.property(:ensure).retrieve).to eq(:absent)
+      expect(pkg.property(:ensure).retrieve).to eq(:purged)
     end
 
     it "should report present packages correctly" do

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

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'puppet/provider/package'
+
+describe Puppet::Provider::Package do
+  it 'returns absent for uninstalled packages when not purgeable' do
+    provider = Puppet::Provider::Package.new
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns false
+    expect(provider.properties[:ensure]).to eq(:absent)
+  end
+
+  it 'returns purged for uninstalled packages when purgeable' do
+    provider = Puppet::Provider::Package.new
+    provider.expects(:query).returns nil
+    provider.class.expects(:feature?).with(:purgeable).returns true
+    expect(provider.properties[:ensure]).to eq(:purged)
+  end
+end

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

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+# Note that much of the functionality of the dnf provider is already tested with yum provider tests,
+# as yum is the parent provider.
+
+provider_class = Puppet::Type.type(:package).provider(:dnf)
+
+describe provider_class do
+  let(:name) { 'mypackage' }
+  let(:resource) do
+    Puppet::Type.type(:package).new(
+      :name => name,
+      :ensure => :installed,
+      :provider => 'dnf'
+    )
+  end
+
+  let(:provider) do
+    provider = provider_class.new
+    provider.resource = resource
+    provider
+  end
+
+  before do
+    provider_class.stubs(:command).with(:cmd).returns('/usr/bin/dnf')
+    provider.stubs(:rpm).returns 'rpm'
+    provider.stubs(:get).with(:version).returns '1'
+    provider.stubs(:get).with(:release).returns '1'
+    provider.stubs(:get).with(:arch).returns 'i386'
+  end
+
+  describe 'provider features' do
+    it { is_expected.to be_versionable }
+    it { is_expected.to be_install_options }
+    it { is_expected.to be_virtual_packages }
+  end
+
+  describe "default provider" do
+    before do
+      Facter.expects(:value).with(:operatingsystem).returns("fedora")
+    end
+
+    it "should be the default provider on Fedora 22" do
+      Facter.expects(:value).with(:operatingsystemmajrelease).returns('22')
+      expect(described_class.default?).to be_truthy
+    end
+
+    it "should be the default provider on Fedora 23" do
+      Facter.expects(:value).with(:operatingsystemmajrelease).returns('23')
+      expect(described_class.default?).to be_truthy
+    end
+  end
+
+  # provider should repond to the following methods
+   [:install, :latest, :update, :purge, :install_options].each do |method|
+     it "should have a(n) #{method}" do
+       expect(provider).to respond_to(method)
+    end
+  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
+      Facter.stubs(:value).with(:operatingsystemmajrelease).returns('22')
+    end
+
+    it 'should call dnf install for :installed' do
+      resource.stubs(:should).with(:ensure).returns :installed
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', :install, 'mypackage'])
+      provider.install
+    end
+
+    it 'should be able to downgrade' do
+      current_version = '1.2'
+      version = '1.0'
+      resource[:ensure] = '1.0'
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', :downgrade, "#{name}-#{version}"])
+      provider.stubs(:query).returns(:ensure => current_version).then.returns(:ensure => version)
+      provider.install
+    end
+
+    it 'should accept install options' do
+      resource[:ensure] = :installed
+      resource[:install_options] = ['-t', {'-x' => 'expackage'}]
+
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-d', '0', '-e', '1', '-y', ['-t', '-x=expackage'], :install, name])
+      provider.install
+    end
+  end
+
+  describe 'when uninstalling' do
+    it 'should use erase to purge' do
+      Puppet::Util::Execution.expects(:execute).with(['/usr/bin/dnf', '-y', :erase, name])
+      provider.purge
+    end
+  end
+
+  describe "executing yum check-update" do
+    it "passes repos to enable to 'yum check-update'" do
+      Puppet::Util::Execution.expects(:execute).with do |args, *rest|
+        expect(args).to eq %w[/usr/bin/dnf check-update --enablerepo=updates --enablerepo=fedoraplus]
+      end.returns(stub(:exitstatus => 0))
+      described_class.check_updates(%w[updates fedoraplus], [], [])
+    end
+  end
+end

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

@@ -88,6 +88,13 @@ context 'installing myresource' do
             provider.install
           end
         end
+        describe "as a windows path on windows", :if => Puppet.features.microsoft_windows? do
+          it "should treat the source as a local path" do
+            resource[:source] = "c:/this/is/a/path/to/a/gem.gem"
+            provider.expects(:execute).with { |args| args[2] == "c:/this/is/a/path/to/a/gem.gem" }.returns ""
+            provider.install
+          end
+        end
         describe "with an invalid uri" do
           it "should fail" do
             URI.expects(:parse).raises(ArgumentError)
@@ -185,6 +192,76 @@ context 'installing myresource' do
         end
       end
     end
+
+    describe 'insync?' do
+      describe 'for array of versions' do
+        let(:is) { ['1.3.4', '3.6.1', '5.1.2'] }
+
+        it 'returns true for ~> 1.3' do
+          resource[:ensure] = '~> 1.3'
+          expect(provider).to be_insync(is)
+        end
+
+        it 'returns false for ~> 2' do
+          resource[:ensure] = '~> 2'
+          expect(provider).to_not be_insync(is)
+        end
+
+        it 'returns true for > 4' do
+          resource[:ensure] = '> 4'
+          expect(provider).to be_insync(is)
+        end
+
+        it 'returns true for 3.6.1' do
+          resource[:ensure] = '3.6.1'
+          expect(provider).to be_insync(is)
+        end
+
+        it 'returns false for 3.6.2' do
+          resource[:ensure] = '3.6.2'
+          expect(provider).to_not be_insync(is)
+        end
+      end
+
+      describe 'for string version' do
+        let(:is) { '1.3.4' }
+
+        it 'returns true for ~> 1.3' do
+          resource[:ensure] = '~> 1.3'
+          expect(provider).to be_insync(is)
+        end
+
+        it 'returns false for ~> 2' do
+          resource[:ensure] = '~> 2'
+          expect(provider).to_not be_insync(is)
+        end
+
+        it 'returns false for > 4' do
+          resource[:ensure] = '> 4'
+          expect(provider).to_not be_insync(is)
+        end
+
+        it 'returns true for 1.3.4' do
+          resource[:ensure] = '1.3.4'
+          expect(provider).to be_insync(is)
+        end
+
+        it 'returns false for 3.6.1' do
+          resource[:ensure] = '3.6.1'
+          expect(provider).to_not be_insync(is)
+        end
+      end
+
+      it 'should return false for bad version specifiers' do
+        resource[:ensure] = 'not a valid gem specifier'
+        expect(provider).to_not be_insync('1.0')
+      end
+
+      it 'should return false for :absent' do
+        resource[:ensure] = '~> 1.0'
+        expect(provider).to_not be_insync(:absent)
+      end
+    end
   end
 end