puppet 4.10.0 → 5.0.0

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/user/directoryservice_spec.rb

@@ -157,7 +157,7 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     "9377c46908a1c8ac2c3e45c0d44da8ad0fcd85ec5c14d9a59ffc40c9da31f0ec"
   end
 
-  # The below value is a Fixnum iterations value used in the PBKDF2
+  # The below value is an Integer iterations value used in the PBKDF2
   # key stretching algorithm
   let(:pbkdf2_iterations_value) do
     24752
@@ -394,12 +394,12 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
       provider.class.prefetch({})
     end
 
-    it 'should return :uid values as a Fixnum' do
-      expect(provider.class.generate_attribute_hash(user_plist_hash)[:uid]).to be_a_kind_of Fixnum
+    it 'should return :uid values as an Integer' do
+      expect(provider.class.generate_attribute_hash(user_plist_hash)[:uid]).to be_a Integer
     end
 
-    it 'should return :gid values as a Fixnum' do
-      expect(provider.class.generate_attribute_hash(user_plist_hash)[:gid]).to be_a_kind_of Fixnum
+    it 'should return :gid values as an Integer' do
+      expect(provider.class.generate_attribute_hash(user_plist_hash)[:gid]).to be_a Integer
     end
 
     it 'should return a hash of resource attributes' do
@@ -799,8 +799,8 @@ describe Puppet::Type.type(:user).provider(:directoryservice) do
     it "should accept a hash containing a PBKDF2 password hash, salt, and iterations value and return the correct iterations value" do
         expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to eq(pbkdf2_iterations_value)
     end
-    it "should return a Fixnum value when looking up the PBKDF2 iterations value" do
-        expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to be_a_kind_of(Fixnum)
+    it "should return an Integer value when looking up the PBKDF2 iterations value" do
+        expect(provider.class.get_salted_sha512_pbkdf2('iterations', pbkdf2_embedded_bplist_hash)).to be_a(Integer)
     end
     it "should raise an error if a field other than 'entropy', 'salt', or 'iterations' is passed" do
       expect { provider.class.get_salted_sha512_pbkdf2('othervalue', pbkdf2_embedded_bplist_hash) }.to raise_error(Puppet::Error, /Puppet has tried to read an incorrect value from the SALTED-SHA512-PBKDF2 hash. Acceptable fields are 'salt', 'entropy', or 'iterations'/)

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

@@ -364,6 +364,19 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         Shadow::Passwd.expects(:getspnam).with('myuser').returns shadow_entry
         expect(provider.send(property)).to eq(expected_value)
       end
+
+      # nameservice provider instances are initialized with a @canonical_name
+      # instance variable to track the original name of the instance on disk
+      # before converting it to UTF-8 if appropriate. When re-querying the
+      # system for attributes of this user such as password info, we need to
+      # supply the pre-UTF8-converted value.
+      it "should query using the canonical_name attribute of the user", :if => Puppet.features.libshadow? do
+        canonical_name = [253, 241].pack('C*').force_encoding(Encoding::EUC_KR)
+        provider = described_class.new(:name => '??', :canonical_name => canonical_name)
+
+        Shadow::Passwd.expects(:getspnam).with(canonical_name).returns shadow_entry
+        provider.password
+      end
     end
   end
 

data/spec/unit/puppet_spec.rb

@@ -2,14 +2,13 @@
 require 'spec_helper'
 require 'puppet'
 require 'puppet_spec/files'
-require 'semver'
 
 describe Puppet do
   include PuppetSpec::Files
 
   context "#version" do
     it "should be valid semver" do
-      expect(SemVer).to be_valid Puppet.version
+      expect(SemanticPuppet::Version).to be_valid Puppet.version
     end
   end
 
@@ -49,7 +48,7 @@ describe Puppet do
     end
 
     it "should match a semver version" do
-      expect(SemVer).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
+      expect(SemanticPuppet::Version).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
     end
   end
 

data/spec/unit/relationship_spec.rb

@@ -151,74 +151,53 @@ describe Puppet::Relationship, " when matching edges with a non-standard event"
   end
 end
 
-describe Puppet::Relationship, "when converting to pson" do
+describe Puppet::Relationship, "when converting to json" do
   before do
-    @edge = Puppet::Relationship.new(:a, :b, :event => :random, :callback => :whatever)
+    @edge = Puppet::Relationship.new('a', 'b', :event => :random, :callback => :whatever)
   end
 
   it "should store the stringified source as the source in the data" do
-    expect(PSON.parse(@edge.to_pson)["source"]).to eq("a")
+    expect(JSON.parse(@edge.to_json)["source"]).to eq("a")
   end
 
   it "should store the stringified target as the target in the data" do
-    expect(PSON.parse(@edge.to_pson)['target']).to eq("b")
+    expect(JSON.parse(@edge.to_json)['target']).to eq("b")
   end
 
-  it "should store the psonified event as the event in the data" do
-    expect(PSON.parse(@edge.to_pson)["event"]).to eq("random")
+  it "should store the jsonified event as the event in the data" do
+    expect(JSON.parse(@edge.to_json)["event"]).to eq("random")
   end
 
   it "should not store an event when none is set" do
     @edge.event = nil
-    expect(PSON.parse(@edge.to_pson)["event"]).to be_nil
+    expect(JSON.parse(@edge.to_json)).not_to include('event')
   end
 
-  it "should store the psonified callback as the callback in the data" do
+  it "should store the jsonified callback as the callback in the data" do
     @edge.callback = "whatever"
-    expect(PSON.parse(@edge.to_pson)["callback"]).to eq("whatever")
+    expect(JSON.parse(@edge.to_json)["callback"]).to eq("whatever")
   end
 
   it "should not store a callback when none is set in the edge" do
     @edge.callback = nil
-    expect(PSON.parse(@edge.to_pson)["callback"]).to be_nil
+    expect(JSON.parse(@edge.to_json)).not_to include('callback')
   end
 end
 
-describe Puppet::Relationship, "when converting from pson" do
-  before do
-    @event = "random"
-    @callback = "whatever"
-    @data = {
-      "source" => "mysource",
-      "target" => "mytarget",
-      "event" => @event,
-      "callback" => @callback
-    }
-    @pson = {
-      "type" => "Puppet::Relationship",
-      "data" => @data
-    }
-  end
-
-  def pson_result_should
-    Puppet::Relationship.expects(:new).with { |*args| yield args }
-  end
-
-  # LAK:NOTE For all of these tests, we convert back to the edge so we can
-  # trap the actual data structure then.
+describe Puppet::Relationship, "when converting from json" do
   it "should pass the source in as the first argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source).to eq("mysource")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").source).to eq('mysource')
   end
 
   it "should pass the target in as the second argument" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target).to eq("mytarget")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget").target).to eq('mytarget')
   end
 
   it "should pass the event as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event).to eq("myevent")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "event" => "myevent", "callback" => "eh").event).to eq(:myevent)
   end
 
   it "should pass the callback as an argument if it's provided" do
-    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback).to eq("mycallback")
+    expect(Puppet::Relationship.from_data_hash("source" => "mysource", "target" => "mytarget", "callback" => "mycallback").callback).to eq(:mycallback)
   end
 end

data/spec/unit/reports/http_spec.rb

@@ -5,7 +5,7 @@ require 'puppet/reports'
 processor = Puppet::Reports.report(:http)
 
 describe processor do
-  subject { Puppet::Transaction::Report.new("apply").extend(processor) }
+  subject { Puppet::Transaction::Report.new.extend(processor) }
 
   describe "when setting up the connection" do
     let(:http) { stub_everything "http" }
@@ -39,6 +39,7 @@ describe processor do
   describe "when making a request" do
     let(:connection) { stub_everything "connection" }
     let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
+    let(:options) { {:metric_id => [:puppet, :report, :http]} }
 
     before :each do
       Puppet::Network::HttpPool.expects(:http_instance).returns(connection)
@@ -46,7 +47,7 @@ describe processor do
 
     it "should use the path specified by the 'reporturl' setting" do
       report_path = URI.parse(Puppet[:reporturl]).path
-      connection.expects(:post).with(report_path, anything, anything, {}).returns(httpok)
+      connection.expects(:post).with(report_path, anything, anything, options).returns(httpok)
 
       subject.process
     end
@@ -54,22 +55,24 @@ describe processor do
     it "should use the username and password specified by the 'reporturl' setting" do
       Puppet[:reporturl] = "https://user:pass@myhost.mydomain:1234/report/upload"
 
-      connection.expects(:post).with(anything, anything, anything, :basic_auth => {
-        :user => 'user',
-        :password => 'pass'
-      }).returns(httpok)
+      connection.expects(:post).with(anything, anything, anything,
+                                     {:metric_id => [:puppet, :report, :http],
+                                      :basic_auth => {
+                                        :user => 'user',
+                                        :password => 'pass'
+                                      }}).returns(httpok)
 
       subject.process
     end
 
     it "should give the body as the report as YAML" do
-      connection.expects(:post).with(anything, subject.to_yaml, anything, {}).returns(httpok)
+      connection.expects(:post).with(anything, subject.to_yaml, anything, options).returns(httpok)
 
       subject.process
     end
 
     it "should set content-type to 'application/x-yaml'" do
-      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), {}).returns(httpok)
+      connection.expects(:post).with(anything, anything, has_entry("Content-Type" => "application/x-yaml"), options).returns(httpok)
 
       subject.process
     end