puppet 4.3.0 → 4.4.0

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

@@ -0,0 +1,241 @@
+require 'spec_helper'
+require 'puppet/pops'
+
+module Puppet::Pops
+module Types
+describe 'Puppet Type System' do
+  let(:tf) { TypeFactory }
+  context 'Integer type' do
+    let!(:a) { tf.range(10, 20) }
+    let!(:b) { tf.range(18, 28) }
+    let!(:c) { tf.range( 2, 12) }
+    let!(:d) { tf.range(12, 18) }
+    let!(:e) { tf.range( 8, 22) }
+    let!(:f) { tf.range( 8,  9) }
+    let!(:g) { tf.range(21, 22) }
+    let!(:h) { tf.range(30, 31) }
+    let!(:i) { tf.float_range(1.0, 30.0) }
+    let!(:j) { tf.float_range(1.0, 9.0) }
+
+    context 'when testing if ranges intersect' do
+      it 'detects an intersection when self is before its argument' do
+        expect(a.intersect?(b)).to be_truthy
+      end
+
+      it 'detects an intersection when self is after its argument' do
+        expect(a.intersect?(c)).to be_truthy
+      end
+
+      it 'detects an intersection when self covers its argument' do
+        expect(a.intersect?(d)).to be_truthy
+      end
+
+      it 'detects an intersection when self equals its argument' do
+        expect(a.intersect?(a)).to be_truthy
+      end
+
+      it 'detects an intersection when self is covered by its argument' do
+        expect(a.intersect?(e)).to be_truthy
+      end
+
+      it 'does not consider an adjacent range to be intersecting' do
+        [f, g].each {|x| expect(a.intersect?(x)).to be_falsey }
+      end
+
+      it 'does not consider an range that is apart to be intersecting' do
+        expect(a.intersect?(h)).to be_falsey
+      end
+
+      it 'does not consider an overlapping float range to be intersecting' do
+        expect(a.intersect?(i)).to be_falsey
+      end
+    end
+
+    context 'when testing if ranges are adjacent' do
+      it 'detects an adjacent type when self is after its argument' do
+        expect(a.adjacent?(f)).to be_truthy
+      end
+
+      it 'detects an adjacent type when self is before its argument' do
+        expect(a.adjacent?(g)).to be_truthy
+      end
+
+      it 'does not consider overlapping types to be adjacent' do
+        [a, b, c, d, e].each { |x| expect(a.adjacent?(x)).to be_falsey }
+      end
+
+      it 'does not consider an range that is apart to be adjacent' do
+        expect(a.adjacent?(h)).to be_falsey
+      end
+
+      it 'does not consider an adjacent float range to be adjancent' do
+        expect(a.adjacent?(j)).to be_falsey
+      end
+    end
+
+    context 'when merging ranges' do
+      it 'will merge intersecting ranges' do
+        expect(a.merge(b)).to eq(tf.range(10, 28))
+      end
+
+      it 'will merge adjacent ranges' do
+        expect(a.merge(g)).to eq(tf.range(10, 22))
+      end
+
+      it 'will not merge ranges that are apart' do
+        expect(a.merge(h)).to be_nil
+      end
+
+      it 'will not merge overlapping float ranges' do
+        expect(a.merge(i)).to be_nil
+      end
+
+      it 'will not merge adjacent float ranges' do
+        expect(a.merge(j)).to be_nil
+      end
+    end
+  end
+
+  context 'Float type' do
+    let!(:a) { tf.float_range(10.0, 20.0) }
+    let!(:b) { tf.float_range(18.0, 28.0) }
+    let!(:c) { tf.float_range( 2.0, 12.0) }
+    let!(:d) { tf.float_range(12.0, 18.0) }
+    let!(:e) { tf.float_range( 8.0, 22.0) }
+    let!(:f) { tf.float_range(30.0, 31.0) }
+    let!(:g) { tf.range(1, 30) }
+
+    context 'when testing if ranges intersect' do
+      it 'detects an intersection when self is before its argument' do
+        expect(a.intersect?(b)).to be_truthy
+      end
+
+      it 'detects an intersection when self is after its argument' do
+        expect(a.intersect?(c)).to be_truthy
+      end
+
+      it 'detects an intersection when self covers its argument' do
+        expect(a.intersect?(d)).to be_truthy
+      end
+
+      it 'detects an intersection when self equals its argument' do
+        expect(a.intersect?(a)).to be_truthy
+      end
+
+      it 'detects an intersection when self is covered by its argument' do
+        expect(a.intersect?(e)).to be_truthy
+      end
+
+      it 'does not consider an range that is apart to be intersecting' do
+        expect(a.intersect?(f)).to be_falsey
+      end
+
+      it 'does not consider an overlapping integer range to be intersecting' do
+        expect(a.intersect?(g)).to be_falsey
+      end
+    end
+
+    context 'when merging ranges' do
+      it 'will merge intersecting ranges' do
+        expect(a.merge(b)).to eq(tf.float_range(10.0, 28.0))
+      end
+
+      it 'will not merge ranges that are apart' do
+        expect(a.merge(f)).to be_nil
+      end
+
+      it 'will not merge overlapping integer ranges' do
+        expect(a.merge(g)).to be_nil
+      end
+    end
+  end
+
+  context 'Optional type' do
+    let!(:overlapping_ints) { tf.variant(tf.range(10, 20), tf.range(18, 28)) }
+    let!(:optoptopt) { tf.optional(tf.optional(tf.optional(overlapping_ints))) }
+    let!(:optnu) { tf.optional(tf.not_undef(overlapping_ints)) }
+
+    context 'when normalizing' do
+      it 'compacts optional in optional in optional to just optional' do
+        expect(optoptopt.normalize).to eq(tf.optional(tf.range(10, 28)))
+      end
+    end
+
+    it 'compacts NotUndef in Optional to just Optional' do
+      expect(optnu.normalize).to eq(tf.optional(tf.range(10, 28)))
+    end
+  end
+
+  context 'NotUndef type' do
+    let!(:nununu) { tf.not_undef(tf.not_undef(tf.not_undef(tf.any))) }
+    let!(:nuopt) { tf.not_undef(tf.optional(tf.any)) }
+
+    context 'when normalizing' do
+      it 'compacts NotUndef in NotUndef in NotUndef to just NotUndef' do
+        expect(nununu.normalize).to eq(tf.not_undef(tf.any))
+      end
+
+      it 'compacts Optional in NotUndef to just NotUndef' do
+        expect(nuopt.normalize).to eq(tf.not_undef(tf.any))
+      end
+    end
+  end
+
+  context 'Variant type' do
+    let!(:overlapping_ints) { tf.variant(tf.range(10, 20), tf.range(18, 28)) }
+    let!(:adjacent_ints) { tf.variant(tf.range(10, 20), tf.range(8, 9)) }
+    let!(:mix_ints) { tf.variant(overlapping_ints, adjacent_ints) }
+    let!(:overlapping_floats) { tf.variant(tf.float_range(10.0, 20.0), tf.float_range(18.0, 28.0)) }
+    let!(:enums) { tf.variant(tf.enum('a', 'b'), tf.enum('b', 'c')) }
+    let!(:patterns) { tf.variant(tf.pattern('a', 'b'), tf.pattern('b', 'c')) }
+    let!(:with_undef) { tf.variant(tf.undef, tf.range(1,10)) }
+    let!(:all_optional) { tf.variant(tf.optional(tf.range(1,10)), tf.optional(tf.range(11,20))) }
+    let!(:groups) { tf.variant(mix_ints, overlapping_floats, enums, patterns, with_undef, all_optional) }
+
+    context 'when normalizing contained types that' do
+      it 'are overlapping ints, the result is a range' do
+        expect(overlapping_ints.normalize).to eq(tf.range(10, 28))
+      end
+
+      it 'are adjacent ints, the result is a range' do
+        expect(adjacent_ints.normalize).to eq(tf.range(8, 20))
+      end
+
+      it 'are mixed variants with adjacent and overlapping ints, the result is a range' do
+        expect(mix_ints.normalize).to eq(tf.range(8, 28))
+      end
+
+      it 'are overlapping floats, the result is a float range' do
+        expect(overlapping_floats.normalize).to eq(tf.float_range(10.0, 28.0))
+      end
+
+      it 'are enums, the result is an enum' do
+        expect(enums.normalize).to eq(tf.enum('a', 'b', 'c'))
+      end
+
+      it 'are patterns, the result is a pattern' do
+        expect(patterns.normalize).to eq(tf.pattern('a', 'b', 'c'))
+      end
+
+      it 'contains an Undef, the result is Optional' do
+        expect(with_undef.normalize).to eq(tf.optional(tf.range(1,10)))
+      end
+
+      it 'are all Optional, the result is an Optional with normalized type' do
+        expect(all_optional.normalize).to eq(tf.optional(tf.range(1,20)))
+      end
+
+      it 'can be normalized in groups, the result is a Variant containing the resulting normalizations' do
+        expect(groups.normalize).to eq(tf.variant(
+          tf.range(8, 28),
+          tf.float_range(10.0, 28.0),
+          tf.enum('a', 'b', 'c'),
+          tf.pattern('a', 'b', 'c'),
+          tf.optional(tf.range(1,20)))
+        )
+      end
+    end
+  end
+end
+end
+end

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

@@ -107,11 +107,51 @@ describe "validating 4x" do
         SOURCE
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::IDEM_NOT_ALLOWED_LAST)
       end
+
+      it "detects a resource declared without title in #{type} when it is the only declaration present" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is in between other declarations" do
+        source = <<-SOURCE
+        #{type} nope {
+            notify { succ: message => 'Nope' }
+            notify { message => 'Nope' }
+            notify { pred: message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is declarated first" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { message => 'Nope' }
+            notify { pred: message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
+
+      it "detects a resource declared without title in #{type} when it is declarated last" do
+        source = <<-SOURCE
+          #{type} nope {
+            notify { succ: message => 'Nope' }
+            notify { message => 'Nope' }
+          }
+        SOURCE
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESOURCE_WITHOUT_TITLE)
+      end
     end
   end
 
   context 'for reserved words' do
-    ['private', 'type', 'attr'].each do |word|
+    ['private', 'attr'].each do |word|
       it "produces an error for the word '#{word}'" do
         source = "$a = #{word}"
         expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::RESERVED_WORD)
@@ -177,6 +217,67 @@ describe "validating 4x" do
     end
   end
 
+  context 'for keywords' do
+    it "should allow using the 'type' as the name of a function with no parameters" do
+      source = "type()"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+
+    it "should allow using the keyword 'type' as the name of a function with parameters" do
+      source = "type('a', 'b')"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+    it "should allow using the 'type' as the name of a function with no parameters and a block" do
+      source = "type() |$x| { $x }"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+
+    it "should allow using the keyword 'type' as the name of a function with parameters and a block" do
+      source = "type('a', 'b') |$x| { $x }"
+      expect(validate(parse(source))).not_to have_any_issues
+    end
+  end
+
+  context 'for parameter names' do
+    ['class', 'define'].each do |word|
+      it "should require that #{word} parameter names are unique" do
+        expect(validate(parse("#{word} foo($a = 10, $a = 20) {}"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
+      end
+    end
+
+    it "should require that template parameter names are unique" do
+      expect(validate(parse_epp("<%-| $a, $a |-%><%= $a == doh %>"))).to have_issue(Puppet::Pops::Issues::DUPLICATE_PARAMETER)
+    end
+  end
+
+  context 'for parameter defaults' do
+    ['class', 'define'].each do |word|
+      it "should not permit assignments in #{word} parameter default expressions" do
+        expect { parse("#{word} foo($a = $x = 10) {}") }.to raise_error(Puppet::ParseErrorWithIssue, /Syntax error at '='/)
+      end
+    end
+
+    ['class', 'define'].each do |word|
+      it "should not permit assignments in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = [$x = 10]) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should not permit assignments to subsequently declared parameters in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = ($b = 3), $b = 5) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should not permit assignments to previously declared parameters in #{word} parameter default nested expressions" do
+        expect(validate(parse("#{word} foo($a = 10, $b = ($a = 10)) {}"))).to have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT)
+      end
+
+      it "should permit assignments in #{word} parameter default inside nested lambda expressions" do
+        expect(validate(parse(
+          "#{word} foo($a = [1,2,3], $b = 0, $c = $a.map |$x| { $b = $x; $b * $a.reduce |$x, $y| {$x + $y}}) {}"))).not_to(
+          have_issue(Puppet::Pops::Issues::ILLEGAL_ASSIGNMENT_CONTEXT))
+      end
+    end
+  end
+
   context 'for reserved parameter names' do
     ['name', 'title'].each do |word|
       it "produces an error when $#{word} is used as a parameter in a class" do
@@ -220,25 +321,68 @@ describe "validating 4x" do
     end
   end
 
-  context 'top level constructs in conditionals' do
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an if expression" do
-        source = "if true { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
-      end
+  context 'top level constructs' do
+    def issue(at_top)
+      at_top ? Puppet::Pops::Issues::NOT_ABSOLUTE_TOP_LEVEL : Puppet::Pops::Issues::NOT_TOP_LEVEL
     end
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an if-else expression" do
-        source = "if false {} else { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
+    # Top level. Defines the expressions that are tested inside of other things
+    {
+      'a class' => ['class x{}', false],
+      'a define' => ['define x{}', false],
+      'a node' => ['node x{}', false],
+      'a function' => ['function x() {}', true],
+      'a type alias' => ['type A = Data', true],
+      'a type alias for a complex type' => ['type C = Hash[String[1],Integer]', true],
+      'a type definition' => ['type A {}', true]
+    }.each_pair do |word, (decl, at_top)|
+      # Nesting level. Defines how each of the top level expressions are nested in
+      # another expression
+      {
+        'a define' => ["define y{ #{decl} }", at_top],
+        'a function' => ["function y() { #{decl} }", at_top],
+        'a type definition' => ["type A { #{decl} }", at_top],
+        'an if expression' => ["if true { #{decl} }", false],
+        'an if-else expression' => ["if false {} else { #{decl} }", false],
+        'an unless' => ["unless false { #{decl} }", false]
+      }.each_pair do |nester, (source, abs_top)|
+        # Tests each top level expression in each nested expression
+        it "produces an error when #{word} is nested in #{nester}" do
+          expect(validate(parse(source))).to have_issue(issue(abs_top))
+        end
+      end
+
+      # Test that the expression can exist anywhere in a top level block
+
+      it "will allow #{word} as the only statement in a top level block" do
+        expect(validate(parse(decl))).not_to have_issue(issue(at_top))
+      end
+
+      it "will allow #{word} as the last statement in a top level block" do
+        source = "$a = 10\n#{decl}"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
+      end
+
+      it "will allow #{word} as the first statement in a top level block" do
+        source = "#{decl}\n$a = 10"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
+      end
+
+      it "will allow #{word} in between other statements in a top level block" do
+        source = "$a = 10\n#{decl}\n$b = 20"
+        expect(validate(parse(source))).not_to have_issue(issue(at_top))
       end
     end
 
-    ['class', 'define', 'node'].each do |word|
-      it "produces an error when $#{word} is nested in an unless expression" do
-        source = "unless false { #{word} x {} }"
-        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::NOT_TOP_LEVEL)
+    context 'that are type aliases' do
+      it 'raises errors when RHS is a name that is an invalid reference' do
+        source = 'type MyInt = integer'
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
+      end
+
+      it 'raises errors when RHS is an AccessExpression with a name that is an invalid reference on LHS' do
+        source = 'type IntegerArray = array[Integer]'
+        expect(validate(parse(source))).to have_issue(Puppet::Pops::Issues::ILLEGAL_EXPRESSION)
       end
     end
   end

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

@@ -139,6 +139,7 @@ describe Puppet::Type.type(:cron).provider(:crontab) do
       expect(described_class.parse_line('MAILTO=""')).to eq({:record_type => :environment, :line => 'MAILTO=""'})
       expect(described_class.parse_line('FOO=BAR')).to eq({:record_type => :environment, :line => 'FOO=BAR'})
       expect(described_class.parse_line('FOO_BAR=BAR')).to eq({:record_type => :environment, :line => 'FOO_BAR=BAR'})
+      expect(described_class.parse_line('SPACE = BAR')).to eq({:record_type => :environment, :line => 'SPACE = BAR'})
     end
 
     it "should extract a cron entry" do

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

@@ -32,9 +32,9 @@ 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
@@ -183,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])
@@ -241,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

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/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/dnf_spec.rb

@@ -35,6 +35,22 @@ describe provider_class do
     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