puppet 6.25.1-x86-mingw32 → 7.0.0-x86-mingw32

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

@@ -1,20 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/compiler'
-
-describe Puppet::Pops::Evaluator::DeferredResolver do
-  include PuppetSpec::Compiler
-
-  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
-  let(:facts) { Puppet::Node::Facts.new('node.example.com') }
-
-  it 'resolves deferred values in a catalog' do
-    catalog = compile_to_catalog(<<~END)
-      notify { "deferred":
-        message => Deferred("join", [[1,2,3], ":"])
-      }
-    END
-    described_class.resolve_and_replace(facts, catalog)
-
-    expect(catalog.resource(:notify, 'deferred')[:message]).to eq('1:2:3')
-  end
-end

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

@@ -1,51 +0,0 @@
-require 'spec_helper'
-require 'puppet/pops'
-
-module Puppet::Pops::Types
-describe 'The enumeration support' do
-  it 'produces an enumerator for Array' do
-  expect(Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
-  end
-
-  it 'produces an enumerator for Hash' do
-    expect(Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
-  end
-
-  it 'produces a char enumerator for String' do
-    enum = Enumeration.enumerator("abc")
-    expect(enum.respond_to?(:next)).to eql(true)
-    expect(enum.next).to eql('a')
-  end
-
-  it 'produces an enumerator for integer times' do
-    enum = Enumeration.enumerator(2)
-    expect(enum.next).to eql(0)
-    expect(enum.next).to eql(1)
-    expect{enum.next}.to raise_error(StopIteration)
-  end
-
-  it 'produces an enumerator for Integer range' do
-    range = TypeFactory.range(1,2)
-    enum = Enumeration.enumerator(range)
-    expect(enum.next).to eql(1)
-    expect(enum.next).to eql(2)
-    expect{enum.next}.to raise_error(StopIteration)
-  end
-
-  it 'does not produce an enumerator for infinite Integer range' do
-    range = TypeFactory.range(1,:default)
-    enum = Enumeration.enumerator(range)
-    expect(enum).to be_nil
-    range = TypeFactory.range(:default,2)
-    enum = Enumeration.enumerator(range)
-    expect(enum).to be_nil
-  end
-
-  [3.14, /.*/, true, false, nil, :something].each do |x|
-    it "does not produce an enumerator for object of type #{x.class}" do
-      enum = Enumeration.enumerator(x)
-      expect(enum).to be_nil
-    end
-  end
-end
-end

data/spec/unit/resource/capability_finder_spec.rb

@@ -1,148 +0,0 @@
-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
-      expect(Puppet::Util).to receive(:const_defined?).with('Puppetdb').and_return(false)
-      expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
-    end
-  end
-
-  context 'when PuppetDB is configured' do
-    before(:each) do
-      allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
-      Puppet.push_context({:loaders => loaders, :current_environment => env})
-      if mock_pdb
-        module Puppet::Util::Puppetdb
-          def query_puppetdb(query); end
-          module_function :query_puppetdb
-
-          class Http
-            def self.action(url); end
-          end
-        end
-      end
-      make_cap_type
-    end
-
-    after(:each) do
-      Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
-      Puppet::Type.rmtype(:cap)
-      Puppet.pop_context()
-    end
-
-    let(:mock_pdb) { !Puppet::Util.const_defined?('Puppetdb') }
-    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) { double('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
-        expect(Puppet::Util::Puppetdb).to receive(:query_puppetdb).and_return(response_body)
-        expect(Puppet::Util::Puppetdb::Http).not_to receive(:action)
-
-        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
-        allow(Puppet::Util::Puppetdb).to receive(:respond_to?).with(:query_puppetdb).and_return(false)
-      end
-
-      it 'should call Puppet::Util::PuppetDB::Http.action' do
-        expect(Puppet::Util::Puppetdb::Http).to receive(:action).and_return(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"}}]
-        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(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
-        allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return([])
-
-        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
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(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
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with(nil, nil, capability).and_return(resources)
-        end
-
-        it 'should return the resource matching code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([{"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 fail if no resource matches code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return([])
-
-          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::Error, /expected exactly one resource but got 2/)
-        end
-
-        it 'should fail if multiple resources match code_id' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', code_id, capability).and_return(resources)
-
-          expect { Puppet::Resource::CapabilityFinder.find('production', code_id, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
-        end
-
-        it 'should fail if no code_id was specified' do
-          allow(Puppet::Resource::CapabilityFinder).to receive(:search).with('production', nil, capability).and_return(resources)
-          expect { Puppet::Resource::CapabilityFinder.find('production', nil, capability) }.to raise_error(Puppet::DevError, /expected exactly one resource but got 2/)
-        end
-      end
-    end
-  end
-end

data/spec/unit/rest/route_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/rest/route'
-
-describe Puppet::Rest::Route do
-  describe '#with_base_url'do
-    let(:dns_resolver) { double('dns resolver') }
-
-    context 'when not using SRV records' do
-      before :each do
-        Puppet.settings[:use_srv_records] = false
-      end
-
-      it "yields a base URL with the values from the specified settings" do
-        Puppet[:ca_server] = 'testserver'
-        Puppet[:ca_port] = 555
-        ca_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
-                                           server_setting: :ca_server,
-                                           port_setting: :ca_port,
-                                           srv_service: :test_service)
-        count = 0
-        rval = ca_route.with_base_url(dns_resolver) do |url|
-          count += 1
-          expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-        expect(rval).to eq('Block return value')
-      end
-
-      it "yields a base URL with Puppet's configured server and port when no defaults are specified" do
-        Puppet[:server] = 'configured.net'
-        Puppet[:serverport] = 8140
-        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
-        count = 0
-        rval = fallback_route.with_base_url(dns_resolver) do |url|
-          count += 1
-          expect(url.to_s).to eq('https://configured.net:8140/fakeapi/v1/')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-        expect(rval).to eq('Block return value')
-      end
-
-      it 'yields the first entry in the server list when server_list is in use' do
-        Puppet[:server_list] = [['one.net', 111], ['two.net', 222]]
-        fallback_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/')
-        count = 0
-        rval = fallback_route.with_base_url(dns_resolver) do |url|
-          count += 1
-          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-        expect(rval).to eq('Block return value')
-      end
-
-      it 'falls back to :server and :serverport if nil is passed' do
-        Puppet[:server] = 'one.net'
-        Puppet[:serverport] = 111
-        nil_route = Puppet::Rest::Route.new(api: '/fakeapi/v1/',
-                                            server_setting: nil,
-                                            port_setting: nil)
-        count = 0
-        rval = nil_route.with_base_url(dns_resolver) do |url|
-          count += 1
-          expect(url.to_s).to eq('https://one.net:111/fakeapi/v1/')
-          'Block return value'
-        end
-        expect(count).to eq(1)
-        expect(rval).to eq('Block return value')
-      end
-    end
-
-    context 'when using SRV records' do
-      context "when SRV returns servers" do
-        let(:route) { Puppet::Rest::Route.new(api: '/fakeapi/v1/',
-                                              srv_service: :test_service) }
-
-        before :each do
-          Puppet.settings[:use_srv_records] = true
-          Puppet.settings[:srv_domain]      = 'example.com'
-
-          @dns_mock = double('dns')
-          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
-
-          @port = 7502
-          @target = 'example.com'
-          record = Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @target)
-          record.instance_variable_set(:@ttl, 10)
-          @srv_records = [record]
-
-          expect(@dns_mock).to receive(:getresources).
-            with("_x-puppet-test_service._tcp.example.com", Resolv::DNS::Resource::IN::SRV).
-            and_return(@srv_records)
-        end
-
-        it "yields a URL using the server and port from the SRV record" do
-          count = 0
-          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
-            count += 1
-            expect(url.to_s).to eq('https://example.com:7502/fakeapi/v1/')
-            'Block return value'
-          end
-          expect(count).to eq(1)
-
-          expect(rval).to eq('Block return value')
-        end
-
-        it "should fall back to the default server when the block raises a SystemCallError" do
-          Puppet[:server] = "testserver"
-          Puppet[:serverport] = 555
-
-          count = 0
-          rval = route.with_base_url(Puppet::Network::Resolver.new) do |url|
-            count += 1
-            if url.to_s =~ /example.com/ then
-              raise SystemCallError, "example failure"
-            else
-              expect(url.to_s).to eq('https://testserver:555/fakeapi/v1/')
-            end
-
-            'Block return value'
-          end
-
-          expect(count).to eq(2)
-          expect(rval).to eq('Block return value')
-        end
-      end
-    end
-  end
-end