puppet 5.5.17 → 5.5.22

data/spec/unit/node_spec.rb

@@ -414,7 +414,9 @@ end
 
 describe Puppet::Node, "when generating the list of names to search through" do
   before do
-    @node = Puppet::Node.new("foo.domain.com", :parameters => {"hostname" => "yay", "domain" => "domain.com"})
+    Puppet[:strict_hostname_checking] = false
+    @node = Puppet::Node.new("foo.domain.com",
+                             :parameters => {"hostname" => "yay", "domain" => "domain.com"})
   end
 
   it "returns an array of names" do
@@ -445,7 +447,6 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'cert'" do
     before do
-      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "cert"
     end
 
@@ -454,8 +455,11 @@ describe Puppet::Node, "when generating the list of names to search through" do
     end
 
     describe "and strict hostname checking is enabled" do
-      it "only uses the passed-in key" do
+      before do
         Puppet[:strict_hostname_checking] = true
+      end
+
+      it "only uses the passed-in key" do
         expect(@node.names).to eq(["foo.domain.com"])
       end
     end
@@ -463,7 +467,6 @@ describe Puppet::Node, "when generating the list of names to search through" do
 
   describe "and :node_name is set to 'facter'" do
     before do
-      Puppet[:strict_hostname_checking] = false
       Puppet[:node_name] = "facter"
     end
 

data/spec/unit/parser/environment_compiler_spec.rb

@@ -367,6 +367,13 @@ EOS
       }.to raise_error(/'Cap\[cap\]' is exported by both 'Prod\[one\]' and 'Prod\[two\]'/)
     end
 
+    it "issues deprecation warnings" do
+      expect {compile_collect_log(MANIFEST_WO_NODE)}.not_to raise_error
+      expect(warnings).to include(/Capability Mapping is deprecated/) # there are two of these
+      expect(warnings).to include(/Application is deprecated/)
+      expect(warnings).to include(/Site Definition is deprecated/)
+    end
+
     context "for producing node" do
       let(:compiled_node) { Puppet::Node.new('first', :environment => env) }
       let(:compiled_catalog) { compile_to_catalog(MANIFEST, compiled_node)}

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -442,21 +442,26 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       }.each do |source, coerced_val|
           it "should warn about numeric coercion in '#{source}' when strict = warning" do
             Puppet[:strict] = :warning
+            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
           it "should not warn about numeric coercion in '#{source}' if strict = off" do
             Puppet[:strict] = :off
+            expect(Puppet::Pops::Evaluator::Runtime3Support::EvaluationError).not_to receive(:new)
             collect_notices(source)
             expect(warnings).to_not include(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
           end
 
         it "should error when finding numeric coercion in '#{source}' if strict = error" do
           Puppet[:strict] = :error
-          expect { parser.evaluate_string(scope, source, __FILE__) }.to raise_error(
-            /The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/
-            )
+          expect {
+            parser.evaluate_string(scope, source, __FILE__)
+          }.to raise_error {|error|
+            expect(error.message).to match(/The string '#{coerced_val}' was automatically coerced to the numerical value #{coerced_val}/)
+            expect(error.backtrace.first).to match(/runtime3_support\.rb.+optionally_fail/)
+          }
         end
       end
 

data/spec/unit/provider/exec_spec.rb

@@ -1,7 +1,12 @@
 require 'spec_helper'
 require 'puppet/provider/exec'
+require 'puppet_spec/compiler'
+require 'puppet_spec/files'
 
 describe Puppet::Provider::Exec do
+  include PuppetSpec::Compiler
+  include PuppetSpec::Files
+
   describe "#extractexe" do
     it "should return the first element of an array" do
       expect(subject.extractexe(['one', 'two'])).to eq('one')
@@ -31,4 +36,208 @@ describe Puppet::Provider::Exec do
       end
     end
   end
+
+  context "when handling sensitive data" do
+    before :each do
+      Puppet[:log_level] = 'debug'
+    end
+
+    let(:supersecret) { 'supersecret' }
+    let(:path) do
+      if Puppet::Util::Platform.windows?
+        # The `apply_compiled_manifest` helper doesn't add the `path` fact, so
+        # we can't reference that in our manifest. Windows PATHs can contain
+        # double quotes and trailing backslashes, which confuse HEREDOC
+        # interpolation below. So sanitize it:
+        ENV['PATH'].split(File::PATH_SEPARATOR).map do |dir|
+          dir.gsub(/"/, '\"').gsub(/\\$/, '')
+        end.join(File::PATH_SEPARATOR)
+      else
+        ENV['PATH']
+      end
+    end
+
+    def ruby_exit_0
+      "ruby -e 'exit 0'"
+    end
+
+    def echo_from_ruby_exit_0(message)
+      # Escape double quotes due to HEREDOC interpolation below
+      "ruby -e 'puts \"#{message}\"; exit 0'".gsub(/"/, '\"')
+    end
+
+    def echo_from_ruby_exit_1(message)
+      # Escape double quotes due to HEREDOC interpolation below
+      "ruby -e 'puts \"#{message}\"; exit 1'".gsub(/"/, '\"')
+    end
+
+    context "when validating the command" do
+      it "redacts the arguments if the command is relative" do
+        expect {
+          apply_compiled_manifest(<<-MANIFEST)
+            exec { 'echo':
+              command => Sensitive.new('echo #{supersecret}')
+            }
+          MANIFEST
+        }.to raise_error do |err|
+          expect(err).to be_a(Puppet::Error)
+          expect(err.message).to match(/'echo' is not qualified and no path was specified. Please qualify the command or specify a path./)
+          expect(err.message).to_not match(/#{supersecret}/)
+        end
+      end
+
+      it "redacts the arguments if the command is a directory" do
+        dir = tmpdir('exec')
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'echo':
+            command => Sensitive.new('#{dir} #{supersecret}'),
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{dir}' is a directory, not a file/))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+      end
+
+      it "redacts the arguments if the command isn't executable" do
+        file = tmpfile('exec')
+        Puppet::FileSystem.touch(file)
+        Puppet::FileSystem.chmod(0644, file)
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'echo':
+            command => Sensitive.new('#{file} #{supersecret}'),
+          }
+        MANIFEST
+        # Execute permission works differently on Windows, but execute will fail since the
+        # file doesn't have a valid extension and isn't a valid executable. The raised error
+        # will be Errno::EIO, which is not useful. The Windows execute code needs to raise
+        # Puppet::Util::Windows::Error so the Win32 error message is preserved.
+        pending("PUP-3561 Needs to raise a meaningful Puppet::Error") if Puppet::Util::Platform.windows?
+        expect(@logs).to include(an_object_having_attributes(level: :err, message: /'#{file}' is not executable/))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+      end
+
+      it "redacts the arguments if the relative command cannot be resolved using the path parameter" do
+        file = File.basename(tmpfile('exec'))
+        dir = tmpdir('exec')
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'echo':
+            command => Sensitive.new('#{file} #{supersecret}'),
+            path    => "#{dir}",
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :err, message: /Could not find command '#{file}'/))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+      end
+    end
+
+    it "redacts the command on success" do
+      command = echo_from_ruby_exit_0(supersecret)
+
+      apply_compiled_manifest(<<-MANIFEST)
+        exec { 'true':
+          command => Sensitive.new("#{command}"),
+          path    => "#{path}",
+        }
+      MANIFEST
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+      expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
+      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+    end
+
+    it "redacts the command on failure" do
+      command = echo_from_ruby_exit_1(supersecret)
+
+      apply_compiled_manifest(<<-MANIFEST)
+        exec { 'false':
+          command => Sensitive.new("#{command}"),
+          path    => "#{path}",
+        }
+      MANIFEST
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[false\]/))
+      expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+      expect(@logs).to include(an_object_having_attributes(level: :err, message: "[command redacted] returned 1 instead of one of [0]"))
+      expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+    end
+
+    context "when handling checks" do
+      let(:onlyifsecret) { "onlyifsecret" }
+      let(:unlesssecret) { "unlesssecret" }
+
+      it "redacts command and onlyif outputs" do
+        onlyif = echo_from_ruby_exit_0(onlyifsecret)
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'true':
+            command => Sensitive.new("#{ruby_exit_0}"),
+            onlyif  => Sensitive.new("#{onlyif}"),
+            path    => "#{path}",
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
+        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
+      end
+
+      it "redacts the command that would have been executed but didn't due to onlyif" do
+        command = echo_from_ruby_exit_0(supersecret)
+        onlyif = echo_from_ruby_exit_1(onlyifsecret)
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'true':
+            command => Sensitive.new("#{command}"),
+            onlyif  => Sensitive.new("#{onlyif}"),
+            path    => "#{path}",
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'onlyif'"))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{onlyifsecret}/))
+      end
+
+      it "redacts command and unless outputs" do
+        unlesscmd = echo_from_ruby_exit_1(unlesssecret)
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'true':
+            command => Sensitive.new("#{ruby_exit_0}"),
+            unless  => Sensitive.new("#{unlesscmd}"),
+            path    => "#{path}",
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing '[redacted]'", source: /Exec\[true\]/))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
+        expect(@logs).to include(an_object_having_attributes(level: :notice, message: "executed successfully"))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
+      end
+
+      it "redacts the command that would have been executed but didn't due to unless" do
+        command = echo_from_ruby_exit_0(supersecret)
+        unlesscmd = echo_from_ruby_exit_0(unlesssecret)
+
+        apply_compiled_manifest(<<-MANIFEST)
+          exec { 'true':
+            command => Sensitive.new("#{command}"),
+            unless  => Sensitive.new("#{unlesscmd}"),
+            path    => "#{path}",
+          }
+        MANIFEST
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing check '[redacted]'"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "Executing: '[redacted]'", source: "Puppet"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "[output redacted]"))
+        expect(@logs).to include(an_object_having_attributes(level: :debug, message: "'[command redacted]' won't be executed because of failed check 'unless'"))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{supersecret}/))
+        expect(@logs).to_not include(an_object_having_attributes(message: /#{unlesssecret}/))
+      end
+    end
+  end
 end

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

@@ -47,7 +47,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
         described_class.has_feature(:libuser)
         resource[:forcelocal] = :true
       end
- 
+
       it "should use lgroupadd instead of groupadd" do
         expect(provider).to receive(:execute).with(including('/usr/sbin/lgroupadd'), hash_including(:custom_environment => hash_including('LIBUSER_CONF')))
         provider.create
@@ -124,6 +124,35 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     end
   end
 
+  describe "#findgroup" do
+    before { allow(File).to receive(:read).with('/etc/group').and_return(content) }
+
+    let(:content) { "sample_group_name:sample_password:sample_gid:sample_user_list" }
+    let(:output) do
+      {
+        group_name: 'sample_group_name',
+        password: 'sample_password',
+        gid: 'sample_gid',
+        user_list: 'sample_user_list',
+      }
+    end
+
+    [:group_name, :password, :gid, :user_list].each do |key|
+      it "finds a group by #{key} when asked" do
+        expect(provider.send(:findgroup, key, "sample_#{key}")).to eq(output)
+      end
+    end
+
+    it "returns false when specified key/value pair is not found" do
+      expect(provider.send(:findgroup, :group_name, 'invalid_group_name')).to eq(false)
+    end
+
+    it "reads the group file only once per resource" do
+      expect(File).to receive(:read).with('/etc/group').once
+      5.times { provider.send(:findgroup, :group_name, 'sample_group_name') }
+    end
+  end
+
   describe "#delete" do
     before do
       allow(provider).to receive(:exists?).and_return(true)

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

@@ -33,13 +33,18 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:user1) { double(:account => 'user1', :domain => '.', :sid => 'user1sid') }
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
+    let(:user_without_domain) { double(:account => 'user_without_domain', :domain => nil, :sid => 'user_without_domain_sid') }
+
     let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
 
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user_without_domain', any_args).and_return(user_without_domain)
       allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user).and_return(nil)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
     end
 
     describe "#members_insync?" do
@@ -199,7 +204,15 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
           ]
           expect(provider.members_insync?(current, ['user2','user1'])).to be_truthy
         end
+
+      it "should return true even if a current user is unresolvable if should is included" do
+        current = [
+            "#{invalid_user}",
+            'user2',
+          ]
+          expect(provider.members_insync?(current, ['user2'])).to be_truthy
       end
+     end
     end
 
     describe "#members_to_s" do
@@ -222,8 +235,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
         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}")
+      it "should return a user string without domain if domain is not set" do
+        expect(provider.members_to_s(['user_without_domain'])).to eq('user_without_domain')
       end
 
       it "should return the username when it cannot be resolved to a SID (for the sake of resource_harness error messages)" do
@@ -237,10 +250,14 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
     let(:user2) { double(:account => 'user2', :domain => '.', :sid => 'user2sid') }
     let(:user3) { double(:account => 'user3', :domain => '.', :sid => 'user3sid') }
 
+    let(:invalid_user) { SecureRandom.uuid }
+    let(:invalid_user_principal) { double(:account => "#{invalid_user}", :domain => nil, :sid => "#{invalid_user}") }
+
     before :each do
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1').and_return(user1)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(user2)
-      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user1', any_args).and_return(user1)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(user2)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(user3)
+      allow(Puppet::Util::Windows::SID).to receive(:name_to_principal).with(invalid_user, true).and_return(invalid_user_principal)
 
       resource[:auth_membership] = true
     end
@@ -261,6 +278,22 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
       expect(provider.members).to match_array(expected_members)
     end
 
+    it "should be able to handle unresolvable SID in list of members" do
+      allow(provider.group).to receive(:members).and_return([
+        'user1',
+        "#{invalid_user}",
+        'user3',
+      ])
+
+      expected_member_sids = [user1.sid, invalid_user_principal.sid, user3.sid]
+      expected_members = ['user1', "#{invalid_user}", 'user3']
+      allow(provider).to receive(:members_to_s)
+        .with(expected_member_sids)
+        .and_return(expected_members.join(','))
+
+      expect(provider.members).to match_array(expected_members)
+    end
+
     it "should be able to set group members" do
       allow(provider.group).to receive(:members).and_return(['user1', 'user2'])
 
@@ -272,8 +305,8 @@ describe Puppet::Type.type(:group).provider(:windows_adsi), :if => Puppet.featur
 
       allow(provider.group).to receive(:member_sids).and_return(member_sids[0..1])
 
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2').and_return(member_sids[1])
-      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3').and_return(member_sids[2])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user2', any_args).and_return(member_sids[1])
+      expect(Puppet::Util::Windows::SID).to receive(:name_to_principal).with('user3', any_args).and_return(member_sids[2])
 
       expect(provider.group).to receive(:remove_member_sids).with(member_sids[0])
       expect(provider.group).to receive(:add_member_sids).with(member_sids[2])

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

@@ -22,16 +22,26 @@ describe Puppet::Type.type(:package).provider(:aix) do
 
   context "when installing" do
     it "should install a package" do
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
       @provider.install
     end
 
     it "should install a specific package version" do
       allow(@resource).to receive(:should).with(:ensure).and_return("1.2.3.4")
+      allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => '1.2.3.4', :status => :committed})
       expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage 1.2.3.4')
       @provider.install
     end
 
+    [:broken, :inconsistent].each do |state|
+      it "should fail if the installation resulted in a '#{state}' state" do
+        allow(@provider).to receive(:query).and_return({:name => 'mypackage', :ensure => 'present', :status => state})
+        expect(@provider).to receive(:installp).with('-acgwXY', '-d', 'mysource', 'mypackage')
+        expect { @provider.install }.to raise_error(Puppet::Error, "Package 'mypackage' is in a #{state} state and requires manual intervention")
+      end
+    end
+
     it "should fail if the specified version is superseded" do
       @resource[:ensure] = '1.2.3.3'
       allow(@provider).to receive(:installp).and_return(<<-OUTPUT)
@@ -126,4 +136,23 @@ END
     expect(described_class).to receive(:execute).and_return('mypackage:mypackage.rte:1.8.6.4::I:T:::::N:A Super Cool Package::::0::\n')
     described_class.prefetch({ 'mypackage' => latest, 'otherpackage' => absent })
   end
+
+  context "when querying instances" do
+    before(:each) do
+      allow(described_class).to receive(:execute).and_return(<<-END.chomp)
+sysmgt.cim.providers:sysmgt.cim.providers.metrics:2.12.1.1: : :B: :Metrics Providers for AIX OS: : : : : : :1:0:/:
+sysmgt.cim.providers:sysmgt.cim.providers.osbase:2.12.1.1: : :C: :Base Providers for AIX OS: : : : : : :1:0:/:
+openssl.base:openssl.base:1.0.2.1800: : :?: :Open Secure Socket Layer: : : : : : :0:0:/:
+END
+    end
+
+    it "should treat installed packages in broken and inconsistent state as absent" do
+      installed_packages = described_class.instances.map { |package| package.properties }
+      expected_packages = [{:name => 'sysmgt.cim.providers.metrics', :ensure => :absent, :status => :broken, :provider => :aix},
+                           {:name => 'sysmgt.cim.providers.osbase', :ensure => '2.12.1.1', :status => :committed, :provider => :aix},
+                           {:name => 'openssl.base', :ensure => :absent, :status => :inconsistent, :provider => :aix}]
+
+      expect(installed_packages).to eql(expected_packages)
+    end
+  end
 end