puppet 4.10.12-x86-mingw32 → 5.0.0-x86-mingw32

data/spec/unit/pops/visitor_spec.rb

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

data/spec/unit/property/list_spec.rb

@@ -35,8 +35,8 @@ describe list_class do
       expect(@property.is_to_s(["foo","bar"])).to eq("foo,bar")
     end
 
-    it "should be able to correctly convert ':absent' to a string" do
-      expect(@property.is_to_s(:absent)).to eq("absent")
+    it "should be able to correctly convert ':absent' to a quoted string" do
+      expect(@property.is_to_s(:absent)).to eq("'absent'")
     end
 
     describe "when adding should to current" do

data/spec/unit/provider/augeas/augeas_spec.rb

@@ -367,7 +367,7 @@ describe provider_class do
       it "should return false for nil" do
         expect(@provider.is_numeric?(nil)).to eq(false)
       end
-      it "should return true for Fixnums" do
+      it "should return true for Integers" do
         expect(@provider.is_numeric?(9)).to eq(true)
       end
       it "should return true for numbers in Strings" do

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

@@ -40,36 +40,23 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:invalid_user) { SecureRandom.uuid }
 
     before :each do
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user1').returns(user1)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user2').returns(user2)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with('user3').returns(user3)
-      Puppet::Util::Windows::SID.stubs(:name_to_principal).with(invalid_user).returns(nil)
+      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 true for same lists of members" do
-        current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-        ]
-        expect(provider.members_insync?(current, ['user1', 'user2'])).to be_truthy
+        expect(provider.members_insync?(['user1', 'user2'], ['user1', 'user2'])).to be_truthy
       end
 
       it "should return true for same lists of unordered members" do
-        current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-        ]
-        expect(provider.members_insync?(current, ['user2', 'user1'])).to be_truthy
+        expect(provider.members_insync?(['user1', 'user2'], ['user2', 'user1'])).to be_truthy
       end
 
       it "should return true for same lists of members irrespective of duplicates" do
-        current = [
-          Puppet::Util::Windows::SID.name_to_principal('user1'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-          Puppet::Util::Windows::SID.name_to_principal('user2'),
-        ]
-        expect(provider.members_insync?(current, ['user2', 'user1', 'user1'])).to be_truthy
+        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
@@ -90,12 +77,7 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when current and should contain the same users in a different order" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
-          ]
-          expect(provider.members_insync?(current, ['user3', 'user1', 'user2'])).to be_truthy
+          expect(provider.members_insync?(['user1', 'user2', 'user3'], ['user3', 'user1', 'user2'])).to be_truthy
         end
 
         it "should return false when current is nil" do
@@ -103,24 +85,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return false when should is nil" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, nil)).to be_falsey
+          expect(provider.members_insync?(['user1'], nil)).to be_falsey
         end
 
         it "should return false when current contains different users than should" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, ['user2'])).to be_falsey
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
         end
 
         it "should return false when current contains members and should is empty" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_falsey
+          expect(provider.members_insync?(['user1'], [])).to be_falsey
         end
 
         it "should return false when current is empty and should contains members" do
@@ -128,19 +101,11 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return false when should user(s) are not the only items in the current" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-          ]
-          expect(provider.members_insync?(current, ['user1'])).to be_falsey
+          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
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_falsey
+          expect(provider.members_insync?(['user1','user2'], [])).to be_falsey
         end
       end
 
@@ -155,24 +120,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when should is nil" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, nil)).to be_truthy
+          expect(provider.members_insync?(['user1'], nil)).to be_truthy
         end
 
         it "should return false when current contains different users than should" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, ['user2'])).to be_falsey
+          expect(provider.members_insync?(['user1'], ['user2'])).to be_falsey
         end
 
         it "should return true when current contains members and should is empty" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_truthy
+          expect(provider.members_insync?(['user1'], [])).to be_truthy
         end
 
         it "should return false when current is empty and should contains members" do
@@ -180,28 +136,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         end
 
         it "should return true when current user(s) contains at least the should list" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-          ]
-          expect(provider.members_insync?(current, ['user1'])).to be_truthy
+          expect(provider.members_insync?(['user1','user2'], ['user1'])).to be_truthy
         end
 
         it "should return true when current user(s) is not empty and should is an empty list" do
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-          ]
-          expect(provider.members_insync?(current, [])).to be_truthy
+          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
-          current = [
-            Puppet::Util::Windows::SID.name_to_principal('user3'),
-            Puppet::Util::Windows::SID.name_to_principal('user1'),
-            Puppet::Util::Windows::SID.name_to_principal('user2'),
-          ]
-          expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
+          expect(provider.members_insync?(['user3','user1','user2'], ['user2','user1'])).to be_truthy
         end
       end
     end
@@ -253,8 +196,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       provider.group.stubs(:member_sids).returns(member_sids[0..1])
 
-      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user2').returns(member_sids[1])
-      Puppet::Util::Windows::SID.expects(:name_to_principal).with('user3').returns(member_sids[2])
+      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user2').returns(member_sids[1])
+      Puppet::Util::Windows::SID.expects(:name_to_sid_object).with('user3').returns(member_sids[2])
 
       provider.group.expects(:remove_member_sids).with(member_sids[0])
       provider.group.expects(:add_member_sids).with(member_sids[2])
@@ -304,7 +247,7 @@ 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::SID.stubs(:name_to_principal).returns(nil)
+    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
 

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

@@ -104,12 +104,4 @@ mypackage                 1.2.3.3         Already superseded by 1.2.3.4
     @provider.expects(:install).with(false)
     @provider.update
   end
-
-  it "should prefetch when some packages lack sources" do
-    latest = Puppet::Type.type(:package).new(:name => 'mypackage', :ensure => :latest, :source => 'mysource', :provider => :aix)
-    absent = Puppet::Type.type(:package).new(:name => 'otherpackage', :ensure => :absent, :provider => :aix)
-    Process.stubs(:euid).returns(0)
-    provider_class.expects(:execute).returns 'mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n'
-    provider_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
-  end
 end

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

@@ -9,28 +9,61 @@ describe provider do
     packagename="sl"
     @resource = stub('resource', :should => true)
     @resource.stubs(:[]).with(:name).returns(packagename)
-    @resource.stubs(:[]).with(:category).returns(nil)
+    @resource.stubs(:[]).with(:install_options).returns(['--foo', '--bar'])
+    @resource.stubs(:[]).with(:uninstall_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
     unslotted_packagename = "dev-lang/ruby"
     @unslotted_resource = stub('resource', :should => true)
+    @unslotted_resource.stubs(:should).with(:ensure).returns :latest
     @unslotted_resource.stubs(:[]).with(:name).returns(unslotted_packagename)
-    @unslotted_resource.stubs(:[]).with(:category).returns(nil)
+    @unslotted_resource.stubs(:[]).with(:install_options).returns([])
 
-    slotted_packagename = "dev-lang/ruby:1.9"
+    slotted_packagename = "dev-lang/ruby:2.1"
     @slotted_resource = stub('resource', :should => true)
     @slotted_resource.stubs(:[]).with(:name).returns(slotted_packagename)
-    @slotted_resource.stubs(:[]).with(:category).returns(nil)
+    @slotted_resource.stubs(:[]).with(:install_options).returns(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
 
+    versioned_packagename = "dev-lang/ruby-1.9.3"
+    @versioned_resource = stub('resource', :should => true)
+    @versioned_resource.stubs(:[]).with(:name).returns(versioned_packagename)
+    @versioned_resource.stubs(:[]).with(:uninstall_options).returns([])
+
+    versioned_slotted_packagename = "=dev-lang/ruby-1.9.3:1.9"
+    @versioned_slotted_resource = stub('resource', :should => true)
+    @versioned_slotted_resource.stubs(:[]).with(:name).returns(versioned_slotted_packagename)
+    @versioned_slotted_resource.stubs(:[]).with(:uninstall_options).returns([])
+
+    set_packagename = "@system"
+    @set_resource = stub('resource', :should => true)
+    @set_resource.stubs(:[]).with(:name).returns(set_packagename)
+    @set_resource.stubs(:[]).with(:install_options).returns([])
+
+    package_sets = "system\nworld\n"
     @provider = provider.new(@resource)
+    @provider.stubs(:qatom).returns({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
     @unslotted_provider = provider.new(@unslotted_resource)
+    @unslotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @unslotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
     @slotted_provider = provider.new(@slotted_resource)
+    @slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>":2.1", :pfx=>nil, :sfx=>nil})
+    @slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @versioned_provider = provider.new(@versioned_resource)
+    @versioned_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @versioned_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @versioned_slotted_provider = provider.new(@versioned_slotted_resource)
+    @versioned_slotted_provider.stubs(:qatom).returns({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>":1.9", :pfx=>"=", :sfx=>nil})
+    @versioned_slotted_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
+    @set_provider = provider.new(@set_resource)
+    @set_provider.stubs(:qatom).returns({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
+    @set_provider.class.stubs(:emerge).with('--list-sets').returns(package_sets)
 
     portage   = stub(:executable => "foo",:execute => true)
     Puppet::Provider::CommandDefiner.stubs(:define).returns(portage)
 
     @nomatch_result = ""
-    @match_result   = "app-misc sl [] [] [] [] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html http://www.izumix.org.uk/sl/ sophisticated graphical program which corrects your miss typing\n"
-    @slot_match_result = "dev-lang ruby [2.0.0] [2.1.0] [1.8.7:1.8,1.9.2:1.9,2.0.0:2.0] [1.9.3:1.9,2.0.1:2.0,2.1.0:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
+    @match_result    = "app-misc sl [] [5.02] [] [] [5.02] [5.02:0] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html https://github.com/mtoyoda/sl/ sophisticated graphical program which corrects your miss typing\n"
+    @slot_match_result = "dev-lang ruby [2.1.8] [2.1.9] [2.1.8:2.1] [2.1.8] [2.1.9,,,,,,,] [2.1.9:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
   end
 
   it "is versionable" do
@@ -41,6 +74,42 @@ describe provider do
     expect(provider).to be_reinstallable
   end
 
+  it 'should support string install options' do
+    @provider.expects(:emerge).with('--foo', '--bar', @resource[:name])
+
+    @provider.install
+  end
+
+  it 'should support updating' do
+    @unslotted_provider.expects(:emerge).with('--update', @unslotted_resource[:name])
+
+    @unslotted_provider.install
+  end
+
+  it 'should support hash install options' do
+    @slotted_provider.expects(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
+
+    @slotted_provider.install
+  end
+
+  it 'should support hash uninstall options' do
+    @provider.expects(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
+
+    @provider.uninstall
+  end
+
+  it 'should support uninstall of specific version' do
+    @versioned_provider.expects(:emerge).with('--rage-clean', @versioned_resource[:name])
+
+    @versioned_provider.uninstall
+  end
+
+  it 'should support uninstall of specific version and slot' do
+    @versioned_slotted_provider.expects(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
+
+    @versioned_slotted_provider.uninstall
+  end
+
   it "uses :emerge to install packages" do
     @provider.expects(:emerge)
 
@@ -60,6 +129,19 @@ describe provider do
     @provider.query
   end
 
+  it "allows to emerge package sets" do
+    @set_provider.expects(:emerge).with(@set_resource[:name])
+
+    @set_provider.install
+  end
+
+  it "allows to emerge and update package sets" do
+    @set_resource.stubs(:should).with(:ensure).returns :latest
+    @set_provider.expects(:emerge).with('--update', @set_resource[:name])
+
+    @set_provider.install
+  end
+
   it "eix arguments must not include --stable" do
     expect(@provider.class.eix_search_arguments).not_to include("--stable")
   end
@@ -84,23 +166,27 @@ describe provider do
   end
 
   it "can provide the package name without slot" do
-    expect(@slotted_provider.package_name_without_slot).to eq("dev-lang/ruby")
+    expect(@unslotted_provider.qatom[:slot]).to be_nil
   end
 
   it "can extract the slot from the package name" do
-    expect(@slotted_provider.package_slot).to eq("1.9")
+    expect(@slotted_provider.qatom[:slot]).to eq(':2.1')
   end
 
   it "returns nil for as the slot when no slot is specified" do
-    expect(@provider.package_slot).to be_nil
+    expect(@provider.qatom[:slot]).to be_nil
   end
 
   it "provides correct package atoms for unslotted packages" do
-    expect(@provider.package_atom_with_version("1.0")).to eq("=sl-1.0")
+    expect(@versioned_provider.qatom[:pv]).to eq('1.9.3')
   end
 
   it "provides correct package atoms for slotted packages" do
-    expect(@slotted_provider.package_atom_with_version("1.9.3")).to eq("=dev-lang/ruby-1.9.3:1.9")
+    expect(@versioned_slotted_provider.qatom[:pfx]).to eq('=')
+    expect(@versioned_slotted_provider.qatom[:category]).to eq('dev-lang')
+    expect(@versioned_slotted_provider.qatom[:pn]).to eq('ruby')
+    expect(@versioned_slotted_provider.qatom[:pv]).to eq('1.9.3')
+    expect(@versioned_slotted_provider.qatom[:slot]).to eq(':1.9')
   end
 
   it "can handle search output with slots for unslotted packages" do
@@ -108,9 +194,9 @@ describe provider do
     @unslotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @unslotted_provider.query
-    expect(result[:name]).to eq("ruby")
-    expect(result[:ensure]).to eq("2.0.0")
-    expect(result[:version_available]).to eq("2.1.0")
+    expect(result[:name]).to eq('ruby')
+    expect(result[:ensure]).to eq('2.1.8')
+    expect(result[:version_available]).to eq('2.1.9')
   end
 
   it "can handle search output with slots" do
@@ -118,8 +204,8 @@ describe provider do
     @slotted_provider.expects(:eix).returns(StringIO.new(@slot_match_result))
 
     result = @slotted_provider.query
-    expect(result[:name]).to eq("ruby")
-    expect(result[:ensure]).to eq("1.9.2")
-    expect(result[:version_available]).to eq("1.9.3")
+    expect(result[:name]).to eq('ruby')
+    expect(result[:ensure]).to eq('2.1.8')
+    expect(result[:version_available]).to eq('2.1.9')
   end
 end

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

@@ -204,9 +204,18 @@ describe provider_class do
   describe "#latest" do
     it "retrieves version string after querying rpm for version from source file" do
       resource.expects(:[]).with(:source).returns('source-string')
-      Puppet::Util::Execution.expects(:execfail).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"], Puppet::Error).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).returns("myresource 0 1.2.3.4 5.el4 noarch\n")
       expect(provider.latest).to eq("1.2.3.4-5.el4")
     end
+
+    it "raises an error if the rpm command fails" do
+      resource.expects(:[]).with(:source).returns('source-string')
+      Puppet::Util::Execution.expects(:execute).with(["/bin/rpm", "-q", "--qf", "'#{nevra_format}'", "-p", "source-string"]).raises(Puppet::ExecutionFailure, 'rpm command failed')
+
+      expect {
+        provider.latest
+      }.to raise_error(Puppet::Error, 'rpm command failed')
+    end
   end
 
   describe "#uninstall" do
@@ -499,6 +508,10 @@ describe provider_class do
     it { expect(provider.rpmvercmp("1.0~rc1~git123", "1.0~rc1")).to eq(-1) }
     it { expect(provider.rpmvercmp("1.0~rc1", "1.0~rc1~git123")).to eq(1) }
     it { expect(provider.rpmvercmp("1.0~rc1", "1.0arc1")).to eq(-1) }
+    it { expect(provider.rpmvercmp("", "~")).to eq(1) }
+    it { expect(provider.rpmvercmp("~", "~~")).to eq(1) }
+    it { expect(provider.rpmvercmp("~", "~+~")).to eq(1) }
+    it { expect(provider.rpmvercmp("~", "~a")).to eq(-1) }
 
     # non-upstream test cases
     it { expect(provider.rpmvercmp("405", "406")).to eq(-1) }

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

@@ -61,15 +61,5 @@ describe provider_class do
         expect(output).to include("yum-plugin-fastestmirror.noarch")
       end
     end
-    describe "with trailing plugin output" do
-      let(:check_update) { File.read(my_fixture("yum-check-update-plugin-output.txt")) }
-      let(:output) { described_class.parse_updates(check_update) }
-      it "parses correctly formatted entries" do
-        expect(output['bash']).to eq([{:name => 'bash', :epoch => '0', :version => '4.2.46', :release => '12.el7', :arch => 'x86_64'}])
-      end
-      it "ignores all mentions of plugin output" do
-        expect(output).not_to include("Random plugin")
-      end
-    end
   end
 end