puppet 4.1.0 → 5.0.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,6 +36,16 @@ 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 an array of strings' do
       provider.user.stubs(:groups).returns nil
@@ -64,9 +76,9 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
 
   describe "#groups_insync?" do
 
-    let(:group1) { stub(:account => 'group1', :domain => '.', :to_s => 'group1sid') }
-    let(:group2) { stub(:account => 'group2', :domain => '.', :to_s => 'group2sid') }
-    let(:group3) { stub(:account => 'group3', :domain => '.', :to_s => 'group3sid') }
+    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)
@@ -99,6 +111,10 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
         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
@@ -222,6 +238,13 @@ 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,
@@ -232,7 +255,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
       resource[:name] = 'DOMAIN\testdomainuser'
       Puppet::Util::Windows::ADSI::Group.expects(:exists?).with(resource[:name]).returns(false)
       connection.expects(:Create)
-      connection.expects(:SetPassword)
+      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(
@@ -243,8 +267,8 @@ describe Puppet::Type.type(:user).provider(:windows_adsi), :if => Puppet.feature
   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

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

@@ -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
 
@@ -39,9 +38,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(SemanticPuppet::Version).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/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

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