puppet 7.28.0-x86-mingw32 → 7.29.0-x86-mingw32

data/spec/integration/indirector/file_metadata/file_server_spec.rb

@@ -1,75 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata/file_server'
-require 'shared_behaviours/file_server_terminus'
-
-require 'puppet_spec/files'
-
-describe Puppet::Indirector::FileMetadata::FileServer, " when finding files" do
-  it_should_behave_like "Puppet::Indirector::FileServerTerminus"
-  include PuppetSpec::Files
-  include_context 'with supported checksum types'
-
-  before do
-    @terminus = Puppet::Indirector::FileMetadata::FileServer.new
-    @test_class = Puppet::FileServing::Metadata
-    Puppet::FileServing::Configuration.instance_variable_set(:@configuration, nil)
-  end
-
-  describe "with a plugin environment specified in the request" do
-    with_checksum_types("file_content_with_env", "mod/lib/file.rb") do
-      it "should return the correct metadata" do
-        Puppet.settings[:modulepath] = "/no/such/file"
-        env = Puppet::Node::Environment.create(:foo, [env_path])
-        result = Puppet::FileServing::Metadata.indirection.search("plugins", :environment => env, :checksum_type => checksum_type, :recurse => true)
-
-        expect(result).to_not be_nil
-        expect(result.length).to eq(2)
-        result.map {|x| expect(x).to be_instance_of(Puppet::FileServing::Metadata)}
-        expect_correct_checksum(result.find {|x| x.relative_path == 'file.rb'}, checksum_type, checksum, Puppet::FileServing::Metadata)
-      end
-    end
-  end
-
-  describe "in modules" do
-    with_checksum_types("file_content", "mymod/files/myfile") do
-      it "should return the correct metadata" do
-        env = Puppet::Node::Environment.create(:foo, [env_path])
-        result = Puppet::FileServing::Metadata.indirection.find("modules/mymod/myfile", :environment => env, :checksum_type => checksum_type)
-        expect_correct_checksum(result, checksum_type, checksum, Puppet::FileServing::Metadata)
-      end
-    end
-  end
-
-  describe "that are tasks in modules" do
-    with_checksum_types("task_file_content", "mymod/tasks/mytask") do
-      it "should return the correct metadata" do
-        env = Puppet::Node::Environment.create(:foo, [env_path])
-        result = Puppet::FileServing::Metadata.indirection.find("tasks/mymod/mytask", :environment => env, :checksum_type => checksum_type)
-        expect_correct_checksum(result, checksum_type, checksum, Puppet::FileServing::Metadata)
-      end
-    end
-  end
-
-  describe "when node name expansions are used" do
-    with_checksum_types("file_server_testing", "mynode/myfile") do
-      it "should return the correct metadata" do
-        allow(Puppet::FileSystem).to receive(:exist?).with(checksum_file).and_return(true)
-        allow(Puppet::FileSystem).to receive(:exist?).with(Puppet[:fileserverconfig]).and_return(true)
-
-        # Use a real mount, so the integration is a bit deeper.
-        mount1 = Puppet::FileServing::Configuration::Mount::File.new("one")
-        mount1.path = File.join(env_path, "%h")
-
-        parser = double('parser', :changed? => false)
-        allow(parser).to receive(:parse).and_return("one" => mount1)
-
-        allow(Puppet::FileServing::Configuration::Parser).to receive(:new).and_return(parser)
-        env = Puppet::Node::Environment.create(:foo, [])
-
-        result = Puppet::FileServing::Metadata.indirection.find("one/myfile", :environment => env, :node => "mynode", :checksum_type => checksum_type)
-        expect_correct_checksum(result, checksum_type, checksum, Puppet::FileServing::Metadata)
-      end
-    end
-  end
-end

data/spec/integration/l10n/compiler_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-describe 'compiler localization' do
-  include_context 'l10n', 'ja'
-
-  let(:envdir) { File.join(my_fixture_dir, '..', 'envs') }
-  let(:environments) do
-    Puppet::Environments::Cached.new(
-      Puppet::Environments::Directories.new(envdir, [])
-    )
-  end
-  let(:env) { Puppet::Node::Environment.create(:prod, [File.join(envdir, 'prod', 'modules')]) }
-  let(:node) { Puppet::Node.new('test', :environment => env) }
-
-  around(:each) do |example|
-    Puppet.override(current_environment: env,
-                    loaders: Puppet::Pops::Loaders.new(env),
-                    environments: environments) do
-      example.run
-    end
-  end
-
-  it 'localizes strings in functions' do
-    Puppet[:code] = <<~END
-      notify { 'demo':
-        message => l10n()
-      }
-    END
-
-    Puppet::Resource::Catalog.indirection.terminus_class = :compiler
-    catalog = Puppet::Resource::Catalog.indirection.find(node.name)
-    resource = catalog.resource(:notify, 'demo')
-
-    expect(resource).to be
-    expect(resource[:message]).to eq("それは楽しい時間です")
-  end
-end

data/spec/integration/network/formats_spec.rb

@@ -1,90 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/formats'
-
-class PsonIntTest
-  attr_accessor :string
-  def ==(other)
-    other.class == self.class and string == other.string
-  end
-
-  def self.from_data_hash(data)
-    new(data[0])
-  end
-
-  def initialize(string)
-    @string = string
-  end
-
-  def to_pson(*args)
-    {
-      'type' => self.class.name,
-      'data' => [@string]
-    }.to_pson(*args)
-  end
-
-  def self.canonical_order(s)
-    s.gsub(/\{"data":\[(.*?)\],"type":"PsonIntTest"\}/,'{"type":"PsonIntTest","data":[\1]}')
-  end
-
-end
-
-describe Puppet::Network::FormatHandler.format(:s) do
-  before do
-    @format = Puppet::Network::FormatHandler.format(:s)
-  end
-
-  it "should support certificates" do
-    expect(@format).to be_supported(Puppet::SSL::Certificate)
-  end
-
-  it "should not support catalogs" do
-    expect(@format).not_to be_supported(Puppet::Resource::Catalog)
-  end
-end
-
-describe Puppet::Network::FormatHandler.format(:pson) do
-  before do
-    @pson = Puppet::Network::FormatHandler.format(:pson)
-  end
-
-  it "should be able to render an instance to pson" do
-    instance = PsonIntTest.new("foo")
-    expect(PsonIntTest.canonical_order(@pson.render(instance))).to eq(PsonIntTest.canonical_order('{"type":"PsonIntTest","data":["foo"]}' ))
-  end
-
-  it "should be able to render arrays to pson" do
-    expect(@pson.render([1,2])).to eq('[1,2]')
-  end
-
-  it "should be able to render arrays containing hashes to pson" do
-    expect(@pson.render([{"one"=>1},{"two"=>2}])).to eq('[{"one":1},{"two":2}]')
-  end
-
-  it "should be able to render multiple instances to pson" do
-    one = PsonIntTest.new("one")
-    two = PsonIntTest.new("two")
-
-    expect(PsonIntTest.canonical_order(@pson.render([one,two]))).to eq(PsonIntTest.canonical_order('[{"type":"PsonIntTest","data":["one"]},{"type":"PsonIntTest","data":["two"]}]'))
-  end
-
-  it "should be able to intern pson into an instance" do
-    expect(@pson.intern(PsonIntTest, '{"type":"PsonIntTest","data":["foo"]}')).to eq(PsonIntTest.new("foo"))
-  end
-
-  it "should be able to intern pson with no class information into an instance" do
-    expect(@pson.intern(PsonIntTest, '["foo"]')).to eq(PsonIntTest.new("foo"))
-  end
-
-  it "should be able to intern multiple instances from pson" do
-    expect(@pson.intern_multiple(PsonIntTest, '[{"type": "PsonIntTest", "data": ["one"]},{"type": "PsonIntTest", "data": ["two"]}]')).to eq([
-      PsonIntTest.new("one"), PsonIntTest.new("two")
-    ])
-  end
-
-  it "should be able to intern multiple instances from pson with no class information" do
-    expect(@pson.intern_multiple(PsonIntTest, '[["one"],["two"]]')).to eq([
-      PsonIntTest.new("one"), PsonIntTest.new("two")
-    ])
-  end
-end

data/spec/integration/network/http/api/indirected_routes_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-require 'puppet/network/http'
-require 'puppet/network/http/api/indirected_routes'
-require 'puppet/indirector_proxy'
-require 'puppet_spec/files'
-require 'puppet_spec/network'
-require 'puppet/util/json'
-require 'puppet/file_serving/content'
-require 'puppet/file_serving/metadata'
-
-describe Puppet::Network::HTTP::API::IndirectedRoutes do
-  include PuppetSpec::Files
-  include PuppetSpec::Network
-  include_context 'with supported checksum types'
-
-  describe "when running the master application" do
-    before :each do
-      Puppet::FileServing::Content.indirection.terminus_class = :file_server
-      Puppet::FileServing::Metadata.indirection.terminus_class = :file_server
-
-      Puppet::FileBucket::File.indirection.terminus_class = :file
-    end
-
-    describe "using Puppet API to request file metadata" do
-      let(:handler) { Puppet::Network::HTTP::API::IndirectedRoutes.new }
-      let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
-
-      with_checksum_types 'file_content', 'lib/files/file.rb' do
-        before :each do
-          Puppet.settings[:modulepath] = env_path
-        end
-
-        it "should find the file metadata with expected checksum" do
-          request = a_request_that_finds(Puppet::IndirectorProxy.new("modules/lib/file.rb", "file_metadata"),
-                                         {:accept_header => 'unknown, text/pson'},
-                                         {:environment => 'production', :checksum_type => checksum_type})
-          handler.call(request, response)
-          resp = Puppet::Util::Json.load(response.body)
-
-          expect(resp['checksum']['type']).to eq(checksum_type)
-          expect(checksum_valid(checksum_type, checksum, resp['checksum']['value'])).to be_truthy
-        end
-
-        it "should search for the file metadata with expected checksum" do
-          request = a_request_that_searches(Puppet::IndirectorProxy.new("modules/lib", "file_metadata"),
-                                            {:accept_header => 'unknown, text/pson'},
-                                            {:environment => 'production', :checksum_type => checksum_type, :recurse => 'yes'})
-          handler.call(request, response)
-          resp = Puppet::Util::Json.load(response.body)
-
-          expect(resp.length).to eq(2)
-          file = resp.find {|x| x['relative_path'] == 'file.rb'}
-
-          expect(file['checksum']['type']).to eq(checksum_type)
-          expect(checksum_valid(checksum_type, checksum, file['checksum']['value'])).to be_truthy
-        end
-      end
-    end
-  end
-end

data/spec/integration/network/http_pool_spec.rb

@@ -1,275 +0,0 @@
-require 'spec_helper'
-require 'puppet_spec/https'
-require 'puppet_spec/files'
-require 'puppet/network/http_pool'
-
-describe Puppet::Network::HttpPool, unless: Puppet::Util::Platform.jruby? do
-  include PuppetSpec::Files
-
-  before :all do
-    WebMock.disable!
-  end
-
-  after :all do
-    WebMock.enable!
-  end
-
-  before :each do
-    # make sure we don't take too long
-    Puppet[:http_connect_timeout] = '5s'
-  end
-
-  let(:hostname) { '127.0.0.1' }
-  let(:wrong_hostname) { 'localhost' }
-  let(:server) { PuppetSpec::HTTPSServer.new }
-
-  context "when calling deprecated HttpPool methods" do
-    before(:each) do
-      ssldir = tmpdir('http_pool')
-      Puppet[:ssldir] = ssldir
-      Puppet.settings.use(:main, :ssl)
-
-      File.write(Puppet[:localcacert], server.ca_cert.to_pem)
-      File.write(Puppet[:hostcrl], server.ca_crl.to_pem)
-      File.write(Puppet[:hostcert], server.server_cert.to_pem)
-      File.write(Puppet[:hostprivkey], server.server_key.to_pem)
-    end
-
-    def connection(host, port)
-      Puppet::Network::HttpPool.http_instance(host, port, use_ssl: true)
-    end
-
-    shared_examples_for 'HTTPS client' do
-      it "connects over SSL" do
-        server.start_server do |port|
-          http = connection(hostname, port)
-          res = http.get('/')
-          expect(res.code).to eq('200')
-        end
-      end
-
-      it "raises if the server's cert doesn't match the hostname we connected to" do
-        server.start_server do |port|
-          http = connection(wrong_hostname, port)
-          expect {
-            http.get('/')
-          }.to raise_error { |err|
-            expect(err).to be_instance_of(Puppet::SSL::CertMismatchError)
-            expect(err.message).to match(/\AServer hostname '#{wrong_hostname}' did not match server certificate; expected one of (.+)/)
-
-            md = err.message.match(/expected one of (.+)/)
-            expect(md[1].split(', ')).to contain_exactly('127.0.0.1', 'DNS:127.0.0.1', 'DNS:127.0.0.2')
-          }
-        end
-      end
-
-      it "raises if the server's CA is unknown" do
-        # File must exist and by not empty so DefaultValidator doesn't
-        # downgrade to VERIFY_NONE, so use a different CA that didn't
-        # issue the server's cert
-        capath = tmpfile('empty')
-        File.write(capath, cert_fixture('netlock-arany-utf8.pem'))
-        Puppet[:localcacert] = capath
-        Puppet[:certificate_revocation] = false
-
-        server.start_server do |port|
-          http = connection(hostname, port)
-          expect {
-            http.get('/')
-          }.to raise_error(Puppet::Error,
-                           %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
-        end
-      end
-
-      it "detects when the server has closed the connection and reconnects" do
-        server.start_server do |port|
-          http = connection(hostname, port)
-
-          expect(http.request_get('/')).to be_a(Net::HTTPSuccess)
-          expect(http.request_get('/')).to be_a(Net::HTTPSuccess)
-        end
-      end
-    end
-
-    context "when using persistent HTTPS connections" do
-      around :each do |example|
-        begin
-          example.run
-        ensure
-          Puppet.runtime[:http].close
-        end
-      end
-
-      include_examples 'HTTPS client'
-    end
-
-    shared_examples_for "an HttpPool connection" do |klass, legacy_api|
-      before :each do
-        Puppet::Network::HttpPool.http_client_class = klass
-      end
-
-      it "connects using the scheme, host and port from the http instance preserving the URL path and query" do
-        request_line = nil
-
-        response_proc = -> (req, res) {
-          request_line = req.request_line
-        }
-
-        server.start_server(response_proc: response_proc) do |port|
-          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
-          path  = "http://bogus.example.com:443/foo?q=a"
-          http.get(path)
-
-          if legacy_api
-            # The old API uses 'absolute-form' and passes the bogus hostname
-            # which isn't the host we connected to.
-            expect(request_line).to eq("GET http://bogus.example.com:443/foo?q=a HTTP/1.1\r\n")
-          else
-            expect(request_line).to eq("GET /foo?q=a HTTP/1.1\r\n")
-          end
-        end
-      end
-
-      it "requires the caller to URL encode the path and query when using absolute form" do
-        request_line = nil
-
-        response_proc = -> (req, res) {
-          request_line = req.request_line
-        }
-
-        server.start_server(response_proc: response_proc) do |port|
-          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
-          params = { 'key' => 'a value' }
-          encoded_url = "https://#{hostname}:#{port}/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}"
-          http.get(encoded_url)
-
-          if legacy_api
-            expect(request_line).to eq("GET #{encoded_url} HTTP/1.1\r\n")
-          else
-            expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
-          end
-        end
-      end
-
-      it "requires the caller to URL encode the path and query when using a path" do
-        request_line = nil
-
-        response_proc = -> (req, res) {
-          request_line = req.request_line
-        }
-
-        server.start_server(response_proc: response_proc) do |port|
-          http = Puppet::Network::HttpPool.http_instance(hostname, port, true)
-          params = { 'key' => 'a value' }
-          http.get("/foo%20bar?q=#{Puppet::Util.uri_query_encode(params.to_json)}")
-
-          expect(request_line).to eq("GET /foo%20bar?q=%7B%22key%22%3A%22a%20value%22%7D HTTP/1.1\r\n")
-        end
-      end
-    end
-
-    describe Puppet::Network::HTTP::Connection do
-      it_behaves_like "an HttpPool connection", described_class, false
-    end
-  end
-
-  context "when calling HttpPool.connection method" do
-    let(:ssl) { Puppet::SSL::SSLProvider.new }
-    let(:ssl_context) { ssl.create_root_context(cacerts: [server.ca_cert], crls: [server.ca_crl]) }
-
-    def connection(host, port, ssl_context:)
-      Puppet::Network::HttpPool.connection(host, port, ssl_context: ssl_context)
-    end
-
-    # Configure the server's SSLContext to require a client certificate. The `client_ca`
-    # setting allows the server to advertise which client CAs it will accept.
-    def require_client_certs(ctx)
-      ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER|OpenSSL::SSL::VERIFY_FAIL_IF_NO_PEER_CERT
-      ctx.client_ca = [cert_fixture('ca.pem')]
-    end
-
-    it "connects over SSL" do
-      server.start_server do |port|
-        http = connection(hostname, port, ssl_context: ssl_context)
-        res = http.get('/')
-        expect(res.code).to eq('200')
-      end
-    end
-
-    it "raises if the server's cert doesn't match the hostname we connected to" do
-      server.start_server do |port|
-        http = connection(wrong_hostname, port, ssl_context: ssl_context)
-        expect {
-          http.get('/')
-        }.to raise_error { |err|
-          expect(err).to be_instance_of(Puppet::SSL::CertMismatchError)
-          expect(err.message).to match(/\AServer hostname '#{wrong_hostname}' did not match server certificate; expected one of (.+)/)
-
-          md = err.message.match(/expected one of (.+)/)
-          expect(md[1].split(', ')).to contain_exactly('127.0.0.1', 'DNS:127.0.0.1', 'DNS:127.0.0.2')
-        }
-      end
-    end
-
-    it "raises if the server's CA is unknown" do
-      server.start_server do |port|
-        ssl_context = ssl.create_root_context(cacerts: [cert_fixture('netlock-arany-utf8.pem')],
-                                              crls: [server.ca_crl])
-        http = Puppet::Network::HttpPool.connection(hostname, port, ssl_context: ssl_context)
-        expect {
-          http.get('/')
-        }.to raise_error(Puppet::Error,
-                         %r{certificate verify failed.* .self signed certificate in certificate chain for CN=Test CA.})
-      end
-    end
-
-    it "warns when client has an incomplete client cert chain" do
-      expect(Puppet).to receive(:warning).with("The issuer 'CN=Test CA Agent Subauthority' of certificate 'CN=pluto' cannot be found locally")
-
-      pluto = cert_fixture('pluto.pem')
-
-      ssl_context = ssl.create_context(
-        cacerts: [server.ca_cert], crls: [server.ca_crl],
-        client_cert: pluto, private_key: key_fixture('pluto-key.pem')
-      )
-
-      # verify client has incomplete chain
-      expect(ssl_context.client_chain.map(&:to_der)).to eq([pluto.to_der])
-
-      # force server to require (not request) client certs
-      ctx_proc = -> (ctx) {
-        require_client_certs(ctx)
-
-        # server needs to trust the client's intermediate CA to complete the client's chain
-        ctx.cert_store.add_cert(cert_fixture('intermediate-agent.pem'))
-      }
-
-      server.start_server(ctx_proc: ctx_proc) do |port|
-        http = Puppet::Network::HttpPool.connection(hostname, port, ssl_context: ssl_context)
-        res = http.get('/')
-        expect(res.code).to eq('200')
-      end
-    end
-
-    it "sends a complete client cert chain" do
-      pluto = cert_fixture('pluto.pem')
-      client_ca = cert_fixture('intermediate-agent.pem')
-
-      ssl_context = ssl.create_context(
-        cacerts: [server.ca_cert, client_ca],
-        crls: [server.ca_crl, crl_fixture('intermediate-agent-crl.pem')],
-        client_cert: pluto,
-        private_key: key_fixture('pluto-key.pem')
-      )
-
-      # verify client has complete chain from leaf to root
-      expect(ssl_context.client_chain.map(&:to_der)).to eq([pluto, client_ca, server.ca_cert].map(&:to_der))
-
-      server.start_server(ctx_proc: method(:require_client_certs)) do |port|
-        http = Puppet::Network::HttpPool.connection(hostname, port, ssl_context: ssl_context)
-        res = http.get('/')
-        expect(res.code).to eq('200')
-      end
-    end
-  end
-end