puppet 4.0.0 → 4.10.0

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

@@ -18,6 +18,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   before :each do
     Puppet::Util::Windows::ADSI.stubs(:computer_name).returns('testcomputername')
     Puppet::Util::Windows::ADSI.stubs(:connect).returns connection
+    # this would normally query the system, but not needed for these tests
+    Puppet::Util::Windows::ADSI::User.stubs(:localized_domains).returns([])
   end
 
   describe ".instances" do
@@ -34,17 +36,29 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     expect(provider.user).to be_a(Puppet::Util::Windows::ADSI::User)
   end
 
+  describe "when retrieving the password property" do
+    context "when the resource has a nil password" do
+      it "should never issue a logon attempt" do
+        resource.stubs(:[]).with(any_of(:name, :password)).returns(nil)
+        Puppet::Util::Windows::User.expects(:logon_user).never
+        provider.password
+      end
+    end
+  end
+
   describe "when managing groups" do
-    it 'should return the list of groups as a comma-separated list' do
-      provider.user.stubs(:groups).returns ['group1', 'group2', 'group3']
+    it 'should return the list of groups as an array of strings' do
+      provider.user.stubs(:groups).returns nil
+      groups = {'group1' => nil, 'group2' => nil, 'group3' => nil}
+      Puppet::Util::Windows::ADSI::Group.expects(:name_sid_hash).returns(groups)
 
-      expect(provider.groups).to eq('group1,group2,group3')
+      expect(provider.groups).to eq(groups.keys)
     end
 
-    it "should return absent if there are no groups" do
+    it "should return an empty array if there are no groups" do
       provider.user.stubs(:groups).returns []
 
-      expect(provider.groups).to eq('')
+      expect(provider.groups).to eq([])
     end
 
     it 'should be able to add a user to a set of groups' do
@@ -60,6 +74,116 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     end
   end
 
+  describe "#groups_insync?" do
+
+    let(:group1) { stub(:account => 'group1', :domain => '.', :sid => 'group1sid') }
+    let(:group2) { stub(:account => 'group2', :domain => '.', :sid => 'group2sid') }
+    let(:group3) { stub(:account => 'group3', :domain => '.', :sid => 'group3sid') }
+
+    before :each do
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group1').returns(group1)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group2').returns(group2)
+      Puppet::Util::Windows::SID.stubs(:name_to_sid_object).with('group3').returns(group3)
+    end
+
+    it "should return true for same lists of members" do
+      expect(provider.groups_insync?(['group1', 'group2'], ['group1', 'group2'])).to be_truthy
+    end
+
+    it "should return true for same lists of unordered members" do
+      expect(provider.groups_insync?(['group1', 'group2'], ['group2', 'group1'])).to be_truthy
+    end
+
+    it "should return true for same lists of members irrespective of duplicates" do
+      expect(provider.groups_insync?(['group1', 'group2', 'group2'], ['group2', 'group1', 'group1'])).to be_truthy
+    end
+
+    it "should return true when current group(s) and should group(s) are empty lists" do
+      expect(provider.groups_insync?([], [])).to be_truthy
+    end
+
+    it "should return true when current groups is empty and should groups is nil" do
+      expect(provider.groups_insync?([], nil)).to be_truthy
+    end
+
+    context "when membership => inclusive" do
+      before :each do
+        resource[:membership] = :inclusive
+      end
+
+      it "should return true when current and should contain the same groups in a different order" do
+        expect(provider.groups_insync?(['group1', 'group2', 'group3'], ['group3', 'group1', 'group2'])).to be_truthy
+      end
+
+      it "should return false when current contains different groups than should" do
+        expect(provider.groups_insync?(['group1'], ['group2'])).to be_falsey
+      end
+
+      it "should return false when current is nil" do
+        expect(provider.groups_insync?(nil, ['group2'])).to be_falsey
+      end
+
+      it "should return false when should is nil" do
+        expect(provider.groups_insync?(['group1'], nil)).to be_falsey
+      end
+
+      it "should return false when current contains members and should is empty" do
+        expect(provider.groups_insync?(['group1'], [])).to be_falsey
+      end
+
+      it "should return false when current is empty and should contains members" do
+        expect(provider.groups_insync?([], ['group2'])).to be_falsey
+      end
+
+      it "should return false when should groups(s) are not the only items in the current" do
+        expect(provider.groups_insync?(['group1', 'group2'], ['group1'])).to be_falsey
+      end
+
+      it "should return false when current group(s) is not empty and should is an empty list" do
+        expect(provider.groups_insync?(['group1','group2'], [])).to be_falsey
+      end
+    end
+
+    context "when membership => minimum" do
+      before :each do
+        # this is also the default
+        resource[:membership] = :minimum
+      end
+
+      it "should return false when current contains different groups than should" do
+        expect(provider.groups_insync?(['group1'], ['group2'])).to be_falsey
+      end
+
+      it "should return false when current is nil" do
+        expect(provider.groups_insync?(nil, ['group2'])).to be_falsey
+      end
+
+      it "should return true when should is nil" do
+        expect(provider.groups_insync?(['group1'], nil)).to be_truthy
+      end
+
+      it "should return true when current contains members and should is empty" do
+        expect(provider.groups_insync?(['group1'], [])).to be_truthy
+      end
+
+      it "should return false when current is empty and should contains members" do
+        expect(provider.groups_insync?([], ['group2'])).to be_falsey
+      end
+
+      it "should return true when current group(s) contains at least the should list" do
+        expect(provider.groups_insync?(['group1','group2'], ['group1'])).to be_truthy
+      end
+
+      it "should return true when current group(s) is not empty and should is an empty list" do
+        expect(provider.groups_insync?(['group1','group2'], [])).to be_truthy
+      end
+
+      it "should return true when current group(s) contains at least the should list, even unordered" do
+        expect(provider.groups_insync?(['group3','group1','group2'], ['group2','group1'])).to be_truthy
+      end
+    end
+  end
+
   describe "when creating a user" do
     it "should create the user on the system and set its other properties" do
       resource[:groups]     = ['group1', 'group2']
@@ -114,16 +238,37 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       expect(provider.password).to be_nil
     end
 
+    it "should test a blank user password" do
+      resource[:password] = ''
+      provider.user.expects(:password_is?).with('').returns true
+
+      expect(provider.password).to eq('')
+    end
+
     it 'should not create a user if a group by the same name exists' do
       Puppet::Util::Windows::ADSI::User.expects(:create).with('testuser').raises( Puppet::Error.new("Cannot create user if group 'testuser' exists.") )
       expect{ provider.create }.to raise_error( Puppet::Error,
         /Cannot create user if group 'testuser' exists./ )
     end
+
+    it "should fail with an actionable message when trying to create an active directory user" do
+      resource[:name] = 'DOMAIN\testdomainuser'
+      Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
+      connection.expects(:Create)
+      connection.expects(:Get).with('UserFlags')
+      connection.expects(:Put).with('UserFlags', true)
+      connection.expects(:SetInfo).raises( WIN32OLERuntimeError.new("(in OLE method `SetInfo': )\n    OLE error code:8007089A in Active Directory\n      The specified username is invalid.\r\n\n    HRESULT error code:0x80020009\n      Exception occurred."))
+
+      expect{ provider.create }.to raise_error(
+        Puppet::Error,
+        /not able to create\/delete domain users/
+      )
+    end
   end
 
   it 'should be able to test whether a user 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 => 'User')
     expect(provider).to be_exists
 
     Puppet::Util::Windows::ADSI.stubs(:connect).returns nil
@@ -136,6 +281,14 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
     provider.delete
   end
 
+  it 'should not run commit on a deleted user' do
+    connection.expects(:Delete).with('user', 'testuser')
+    connection.expects(:SetInfo).never
+
+    provider.delete
+    provider.flush
+  end
+
   it 'should delete the profile if managehome is set' do
     resource[:managehome] = true
 

data/spec/unit/provider/yumrepo/inifile_spec.rb

@@ -249,6 +249,22 @@ describe Puppet::Type.type(:yumrepo).provider(:inifile) do
       expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d")
     end
 
+    it "includes the directory if the value is split by whitespace" do
+      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
+      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
+
+      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d /etc/yum/misc.repos.d"
+      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
+    end
+
+    it "includes the directory if the value is split by new lines" do
+      Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(true)
+      Puppet::FileSystem.expects(:exist?).with("/etc/yum/misc.repos.d").returns(true)
+
+      described_class.expects(:find_conf_value).with('reposdir', '/etc/yum.conf').returns "/etc/yum/extra.repos.d\n/etc/yum/misc.repos.d"
+      expect(described_class.reposdir('/etc/yum.conf')).to include("/etc/yum/extra.repos.d", "/etc/yum/misc.repos.d")
+    end
+
     it "doesn't include the directory specified by the yum.conf 'reposdir' entry when the directory is absent" do
       Puppet::FileSystem.expects(:exist?).with("/etc/yum/extra.repos.d").returns(false)
 

data/spec/unit/provider/zone/solaris_spec.rb

@@ -85,7 +85,8 @@ describe Puppet::Type.type(:zone).provider(:solaris) do
     end
   end
   context "#getconfig" do
-    zone_info =<<-EOF
+    describe "with a shared iptype zone" do
+      zone_info =<<-EOF
 zonename: dummy
 zonepath: /dummy/z
 brand: native
@@ -104,17 +105,68 @@ net:
         address: 1.1.1.2
         physical: ex0002
         defrouter not specified
-    EOF
-    it "should correctly parse zone info" do
-      provider.expects(:zonecfg).with(:info).returns(zone_info)
-      expect(provider.getconfig).to eq({
-        :brand=>"native",
-        :autoboot=>"true",
-        :"ip-type"=>"shared",
-        :zonename=>"dummy",
-        "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
-        :zonepath=>"/dummy/z"
-      })
+      EOF
+      it "should correctly parse zone info" do
+        provider.expects(:zonecfg).with(:info).returns(zone_info)
+        expect(provider.getconfig).to eq({
+          :brand=>"native",
+          :autoboot=>"true",
+          :"ip-type"=>"shared",
+          :zonename=>"dummy",
+          "net"=>[{:physical=>"ex0001", :address=>"1.1.1.1"}, {:physical=>"ex0002", :address=>"1.1.1.2"}],
+          :zonepath=>"/dummy/z"
+        })
+      end
+    end
+    describe "with an exclusive iptype zone" do
+      zone_info =<<-EOF
+zonename: dummy
+zonepath: /dummy/z
+brand: native
+autoboot: true
+bootargs:
+pool:
+limitpriv:
+scheduling-class:
+ip-type: exclusive
+hostid:
+net:
+        address not specified
+        allowed-address not specified
+        configure-allowed-address: true
+        physical: net1
+        defrouter not specified
+      EOF
+      it "should correctly parse zone info" do
+        provider.expects(:zonecfg).with(:info).returns(zone_info)
+        expect(provider.getconfig).to eq({
+          :brand=>"native",
+          :autoboot=>"true",
+          :"ip-type"=>"exclusive",
+          :zonename=>"dummy",
+          "net"=>[{:physical=>"net1",:'configure-allowed-address'=>"true"}],
+          :zonepath=>"/dummy/z"
+        })
+      end
+    end
+    describe "with an invalid or unrecognized config" do
+      it "should produce an error message with provider context when given an invalid config" do
+        erroneous_zone_info =<<-EOF
+          physical: net1'
+        EOF
+
+        provider.expects(:zonecfg).with(:info).returns(erroneous_zone_info)
+        provider.expects('err').with("Ignoring '          physical: net1''")
+        provider.getconfig
+      end
+
+
+      it "should produce a debugging message with provider context when given an unrecognized config" do
+        unrecognized_zone_info = "dummy"
+        provider.expects(:zonecfg).with(:info).returns(unrecognized_zone_info)
+        provider.expects('debug').with("Ignoring zone output 'dummy'")
+        provider.getconfig
+      end
     end
   end
   context "#flush" do

data/spec/unit/puppet_spec.rb

@@ -39,9 +39,23 @@ describe Puppet do
     expect($LOAD_PATH).to include two
   end
 
+  context "Puppet::OLDEST_RECOMMENDED_RUBY_VERSION" do
+    it "should have an oldest recommended ruby version constant" do
+      expect(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION).not_to be_nil
+    end
+
+    it "should be a string" do
+      expect(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION).to be_a_kind_of(String)
+    end
+
+    it "should match a semver version" do
+      expect(SemVer).to be_valid(Puppet::OLDEST_RECOMMENDED_RUBY_VERSION)
+    end
+  end
+
   context "newtype" do
     it "should issue a deprecation warning" do
-      subject.expects(:deprecation_warning).with("Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
+      subject.expects(:deprecation_warning).with("Creating sometype via Puppet.newtype is deprecated and will be removed in a future release. Use Puppet::Type.newtype instead.")
       subject.newtype("sometype")
     end
   end

data/spec/unit/reports_spec.rb

@@ -43,6 +43,16 @@ describe Puppet::Reports, " when registering report types" do
     Puppet::Reports.register_report(:testing) { }
   end
 
+  it "should allow a successful report to be reloaded" do
+    Puppet::Reports.register_report(:testing) { }
+    Puppet::Reports.register_report(:testing) { }
+  end
+
+  it "should allow a failed report to be reloaded and show the correct exception both times" do
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+    expect { Puppet::Reports.register_report(:testing) { raise TypeError, 'failed report' } }.to raise_error(TypeError)
+  end
+
   it "should extend the report type with the Puppet::Util::Docs module" do
     mod = stub 'module', :define_method => true
 

data/spec/unit/resource/capability_finder_spec.rb

@@ -0,0 +1,147 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require_relative '../pops/parser/parser_rspec_helper'
+require 'puppet/resource/capability_finder'
+
+describe Puppet::Resource::CapabilityFinder do
+  context 'when PuppetDB is not configured' do
+    it 'should error' do
+      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
+    end
+  end
+
+  context 'when PuppetDB is configured' do
+    around(:each) do |example|
+      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+      if mock_pdb
+        module Puppet::Util::Puppetdb
+          class Http; end
+        end
+      end
+      begin
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          make_cap_type
+          example.run
+        end
+      ensure
+        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+        Puppet::Type.rmtype(:cap)
+        Puppet::Pops::Loaders.clear
+      end
+    end
+
+    let(:env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+    let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
+    let(:response) { stub('response', :body => response_body.to_json) }
+
+    def make_cap_type
+      Puppet::Type.newtype :cap, :is_capability => true do
+        newparam :name
+        newparam :host
+      end
+    end
+
+    describe "when query_puppetdb method is available" do
+      it 'should call use the query_puppetdb method if available' do
+        Puppet::Util::Puppetdb.expects(:query_puppetdb).returns(response_body)
+        Puppet::Util::Puppetdb::Http.expects(:action).never
+
+        result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
+    end
+
+    describe "when query_puppetdb method is unavailable" do
+      before :each do
+        Puppet::Util::Puppetdb.stubs(:respond_to?).with(:query_puppetdb).returns false
+      end
+
+      it 'should call Puppet::Util::PuppetDB::Http.action' do
+        Puppet::Util::Puppetdb::Http.expects(:action).returns(response)
+        result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
+    end
+
+    describe '#find' do
+      let(:capability) { Puppet::Resource.new('Cap', 'cap') }
+      let(:code_id) { 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe' }
+
+      it 'should search for the resource without including code_id or environment' do
+        resources = [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}]
+        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+
+        result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
+
+      it 'should return nil if no resource is found' do
+        Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns []
+
+        result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
+        expect(result).to be_nil
+      end
+
+      describe 'when multiple results are returned for different environments' do
+        let(:resources) do
+          [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}, "tags"=>["producer:production"]},
+           {"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"bhost"}, "tags"=>["producer:other_env"]}]
+        end
+
+        before :each do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+        end
+
+        it 'should return the resource matching environment' do
+          result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
+          expect(result['host']).to eq('ahost')
+        end
+
+        it 'should return nil if no resource matches environment' do
+          result = Puppet::Resource::CapabilityFinder.find('bad_env', code_id, capability)
+          expect(result).to be_nil
+        end
+      end
+
+      describe 'when multiple results are returned for the same environment' do
+        let(:resources) do
+          [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}, "tags"=>["producer:production"]},
+           {"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"bhost"}, "tags"=>["producer:production"]}]
+        end
+
+        before :each do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with(nil, nil, capability).returns resources
+        end
+
+        it 'should return the resource matching code_id' do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"chost"}}]
+
+          result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
+          expect(result['host']).to eq('chost')
+        end
+
+        it 'should return nil if no resource matches code_id' do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns []
+
+          result = Puppet::Resource::CapabilityFinder.find('production', code_id, capability)
+          expect(result).to be_nil
+        end
+
+        it 'should fail if multiple resources match code_id' do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', code_id, capability).returns resources
+
+          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+        end
+
+        it 'should fail if no code_id was specified' do
+          Puppet::Resource::CapabilityFinder.stubs(:search).with('production', nil, capability).returns resources
+          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource/)
+        end
+      end
+    end
+  end
+end