puppet 6.17.0-x64-mingw32 → 7.1.0-x64-mingw32

data/spec/unit/network/http/api/master/v3/environment_spec.rb

@@ -1,185 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/http'
-
-describe Puppet::Network::HTTP::API::Master::V3::Environment do
-  let(:response) { Puppet::Network::HTTP::MemoryResponse.new }
-
-  let(:environment) { Puppet::Node::Environment.create(:production, [], '/manifests') }
-  let(:loader) { Puppet::Environments::Static.new(environment) }
-
-  around :each do |example|
-    Puppet.override(:environments => loader) do
-      Puppet::Type.newtype :sql, :is_capability => true do
-        newparam :name, :namevar => true
-      end
-      Puppet::Type.newtype :http, :is_capability => true do
-        newparam :name, :namevar => true
-      end
-      example.run
-    end
-  end
-
-  it "returns the environment catalog" do
-    request = Puppet::Network::HTTP::Request.from_hash(:headers => { 'accept' => 'application/json' }, :routing_path => "environment/production")
-
-    subject.call(request, response)
-
-    expect(response.code).to eq(200)
-
-    catalog = JSON.parse(response.body)
-    expect(catalog['environment']).to eq('production')
-    expect(catalog['applications']).to eq({})
-  end
-
-  describe "processing the environment catalog" do
-    def compile_site_to_catalog(site, code_id=nil)
-      Puppet[:code] = <<-MANIFEST
-      define db() { }
-      Db produces Sql { }
-
-      define web() { }
-      Web consumes Sql { }
-      Web produces Http { }
-
-      application myapp() {
-        db { $name:
-          export => Sql[$name],
-        }
-        web { $name:
-          consume => Sql[$name],
-          export => Http[$name],
-        }
-      }
-      site {
-        #{site}
-      }
-      MANIFEST
-      Puppet::Parser::EnvironmentCompiler.compile(environment, code_id).filter { |r| r.virtual? }
-    end
-
-
-    it "includes specified applications" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => Db['test'],
-          Node['bar.example.com'] => Web['test'],
-        },
-      }
-      MANIFEST
-
-      result = subject.build_environment_graph(catalog)
-
-      expect(result[:applications]).to eq({'Myapp[test]' =>
-                                            {'Db[test]' => {:produces => ['Sql[test]'], :consumes => [], :node => 'foo.example.com'},
-                                             'Web[test]' => {:produces => ['Http[test]'], :consumes => ['Sql[test]'], :node => 'bar.example.com'}}})
-    end
-
-    it "fails if a component isn't mapped to a node" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => Db['test'],
-        }
-      }
-      MANIFEST
-
-      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /has components without assigned nodes/)
-    end
-
-    it "fails if a non-existent component is mapped to a node" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => [ Db['test'], Web['test'], Web['foobar'] ],
-        }
-      }
-      MANIFEST
-
-      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
-    end
-
-    it "fails if a component is mapped twice" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
-          Node['bar.example.com'] => [ Web['test'] ],
-        }
-      }
-      MANIFEST
-
-      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns multiple nodes to component/)
-    end
-
-    it "fails if an application maps components from other applications" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => [ Db['test'], Web['test'] ],
-        }
-      }
-      myapp { 'other':
-        nodes => {
-          Node['foo.example.com'] => [ Db['other'], Web['other'], Web['test'] ],
-        }
-      }
-      MANIFEST
-
-      expect { subject.build_environment_graph(catalog) }.to raise_error(Puppet::ParseError, /assigns nodes to non-existent components/)
-    end
-
-    it "doesn't fail if the catalog contains a node cycle" do
-      catalog = compile_site_to_catalog <<-MANIFEST
-      myapp { 'test':
-        nodes => {
-          Node['foo.example.com'] => [ Db['test'] ],
-          Node['bar.example.com'] => [ Web['test'] ],
-        }
-      }
-      myapp { 'other':
-        nodes => {
-          Node['foo.example.com'] => [ Web['other'] ],
-          Node['bar.example.com'] => [ Db['other'] ],
-        }
-      }
-      MANIFEST
-
-      expect { subject.build_environment_graph(catalog) }.not_to raise_error
-    end
-  end
-
-  it "returns 404 if the environment doesn't exist" do
-    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/development")
-
-    expect { subject.call(request, response) }.to raise_error(Puppet::Network::HTTP::Error::HTTPNotFoundError, /development is not a known environment/)
-  end
-
-  it "omits code_id if unspecified" do
-    request = Puppet::Network::HTTP::Request.from_hash(:routing_path => "environment/production")
-
-    subject.call(request, response)
-
-    expect(JSON.parse(response.body)['code_id']).to be_nil
-  end
-
-  it "includes code_id if specified" do
-    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
-
-    subject.call(request, response)
-
-    expect(JSON.parse(response.body)['code_id']).to eq('12345')
-  end
-
-  it "uses code_id from the catalog if it differs from the request" do
-    request = Puppet::Network::HTTP::Request.from_hash(:params => {:code_id => '12345'}, :routing_path => "environment/production")
-
-    allow_any_instance_of(Puppet::Resource::Catalog).to receive(:code_id).and_return('67890')
-
-    subject.call(request, response)
-
-    expect(JSON.parse(response.body)['code_id']).to eq('67890')
-  end
-end
-

data/spec/unit/network/http/compression_spec.rb

@@ -1,240 +0,0 @@
-require 'spec_helper'
-
-describe "http compression" do
-  let(:data)            { "uncompresseddata" }
-  let(:response)        { double('response') }
-  let(:compressed_zlib) { Zlib::Deflate.deflate(data) }
-  let(:compressed_gzip) do
-    str = StringIO.new
-    writer = Zlib::GzipWriter.new(str)
-    writer.write(data)
-    writer.close
-    str.string
-  end
-
-  def stubs_response_with(response, content_encoding, body)
-    allow(response).to receive(:[]).with('content-encoding').and_return(content_encoding)
-    allow(response).to receive(:body).and_return(body)
-  end
-
-  describe "when zlib is not available" do
-    before(:each) do
-      allow(Puppet.features).to receive(:zlib?).and_return(false)
-
-      require 'puppet/network/http/compression'
-      class HttpUncompressor
-        include Puppet::Network::HTTP::Compression::None
-      end
-
-      @uncompressor = HttpUncompressor.new
-    end
-
-    it "should have a module function that returns the None underlying module" do
-      expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::None)
-    end
-
-    it "should not add any Accept-Encoding header" do
-      expect(@uncompressor.add_accept_encoding({})).to eq({})
-    end
-
-    it "should not tamper the body" do
-      response = double('response', :body => data)
-      expect(@uncompressor.uncompress_body(response)).to eq(data)
-    end
-
-    it "should yield an identity uncompressor" do
-      response = double('response')
-      @uncompressor.uncompress(response) { |u|
-        expect(u).to be_instance_of(Puppet::Network::HTTP::Compression::IdentityAdapter)
-      }
-    end
-  end
-
-  describe "when zlib is available" do
-    require 'puppet/network/http/compression'
-    class ActiveUncompressor
-      include Puppet::Network::HTTP::Compression::Active
-    end
-
-    let(:uncompressor) { ActiveUncompressor.new }
-
-    it "should have a module function that returns the Active underlying module" do
-      expect(Puppet::Network::HTTP::Compression.module).to eq(Puppet::Network::HTTP::Compression::Active)
-    end
-
-    it "should add an Accept-Encoding header supporting compression" do
-      headers = uncompressor.add_accept_encoding({})
-      expect(headers).to have_key('accept-encoding')
-      expect(headers['accept-encoding']).to match(/gzip/)
-      expect(headers['accept-encoding']).to match(/deflate/)
-      expect(headers['accept-encoding']).to match(/identity/)
-    end
-
-    describe "when uncompressing response body" do
-      context "without compression" do
-        it "should return untransformed response body with no content-encoding" do
-          stubs_response_with(response, nil, data)
-
-          expect(uncompressor.uncompress_body(response)).to eq(data)
-        end
-
-        it "should return untransformed response body with 'identity' content-encoding" do
-          stubs_response_with(response, 'identity', data)
-
-          expect(uncompressor.uncompress_body(response)).to eq(data)
-        end
-      end
-
-      context "with 'zlib' content-encoding" do
-        it "should use a Zlib inflater" do
-          stubs_response_with(response, 'deflate', compressed_zlib)
-
-          expect(uncompressor.uncompress_body(response)).to eq(data)
-        end
-
-      end
-
-      context "with 'gzip' content-encoding" do
-        it "should use a GzipReader" do
-          stubs_response_with(response, 'gzip', compressed_gzip)
-
-          expect(uncompressor.uncompress_body(response)).to eq(data)
-        end
-
-        it "should correctly decompress PSON containing UTF-8 in Binary Encoding" do
-          # Simulate a compressed response body containing PSON containing UTF-8
-          # using different UTF-8 widths:
-
-          # \u06ff - ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-          # \u16A0 - ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-          # \u{2070E} - 𠜎 - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-
-          pson = "foo\u06ff\u16A0\u{2070E}".to_pson # unicode expression eqivalent of "foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\" per above
-          compressed_body_io = StringIO.new
-          writer = Zlib::GzipWriter.new(compressed_body_io)
-          writer.write(pson)
-          writer.close
-          compressed_body = compressed_body_io.string
-
-          begin
-            default_external = Encoding.default_external
-            Encoding.default_external = Encoding::ISO_8859_1
-
-            stubs_response_with(response, 'gzip', compressed_body)
-
-            uncompressed = uncompressor.uncompress_body(response)
-            # By default Zlib::GzipReader decompresses into Encoding.default_external, and we want to ensure our result is BINARY too
-            expect(uncompressed.encoding).to eq(Encoding::BINARY)
-            expect(uncompressed).to eq("\"foo\xDB\xBF\xE1\x9A\xA0\xF0\xA0\x9C\x8E\"".force_encoding(Encoding::BINARY))
-          ensure
-            Encoding.default_external = default_external
-          end
-        end
-      end
-    end
-
-    describe "when uncompressing by chunk" do
-      it "should yield an identity uncompressor with no content-encoding" do
-        stubs_response_with(response, nil, data)
-
-        expect { |b|
-          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
-        }
-      end
-
-      it "should yield an identity uncompressor with 'identity' content-encoding" do
-        stubs_response_with(response, 'identity', data)
-
-        expect { |b|
-          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::IdentityAdapter, &b)
-        }
-      end
-
-      it "should yield a Zlib uncompressor with 'gzip' content-encoding" do
-        stubs_response_with(response, 'gzip', compressed_gzip)
-
-        expect { |b|
-          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
-        }
-      end
-
-      it "should yield a Zlib uncompressor with 'deflate' content-encoding" do
-        stubs_response_with(response, 'deflate', compressed_zlib)
-
-        expect { |b|
-          uncompressor.uncompress(response).yield_once_with(Puppet::Network::HTTP::Compression::ZlibAdapter, &b)
-        }
-      end
-
-      it "should close the underlying adapter" do
-        stubs_response_with(response, 'identity', data)
-        adapter = double('adapter')
-        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
-
-        expect(adapter).to receive(:close)
-        uncompressor.uncompress(response) { |u| }
-      end
-
-      it "should close the underlying adapter if the yielded block raises" do
-        stubs_response_with(response, 'identity', data)
-        adapter = double('adapter')
-        expect(Puppet::Network::HTTP::Compression::IdentityAdapter).to receive(:new).and_return(adapter)
-
-        expect(adapter).to receive(:close)
-        expect {
-          uncompressor.uncompress(response) { |u| raise ArgumentError, "whoops" }
-        }.to raise_error(ArgumentError, "whoops")
-      end
-    end
-
-    describe "zlib adapter" do
-      it "should initialize the underlying inflater with gzip/zlib header parsing" do
-        expect(Zlib::Inflate).to receive(:new).with(15 + 32)
-
-        Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
-      end
-
-      it "should return the given chunk" do
-        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new
-
-        expect(adapter.uncompress(compressed_zlib)).to eq(data)
-      end
-
-      it "should try a 'regular' inflater on Zlib::DataError" do
-        inflater = Zlib::Inflate.new(15 + 32)
-        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
-        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
-
-        expect(adapter.uncompress(compressed_zlib)).to eq(data)
-      end
-
-      it "should raise the error the second time" do
-        inflater = Zlib::Inflate.new(15 + 32)
-        expect(inflater).to receive(:inflate).and_raise(Zlib::DataError.new("not a zlib stream"))
-        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
-
-        expect { adapter.uncompress("this is not compressed data") }.to raise_error(Zlib::DataError, /incorrect header check/)
-      end
-
-      it "should finish and close the stream" do
-        inflater = double('inflater')
-        expect(inflater).to receive(:finish)
-        expect(inflater).to receive(:close)
-        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
-
-        adapter.close
-      end
-
-      it "should close the stream even if finish raises" do
-        inflater = double('inflater')
-        expect(inflater).to receive(:finish).and_raise(Zlib::BufError)
-        expect(inflater).to receive(:close)
-
-        adapter = Puppet::Network::HTTP::Compression::Active::ZlibAdapter.new(inflater)
-        expect {
-          adapter.close
-        }.to raise_error(Zlib::BufError)
-      end
-    end
-  end
-end

data/spec/unit/network/http/nocache_pool_spec.rb

@@ -1,64 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/network/http'
-require 'puppet/network/http/connection'
-
-describe Puppet::Network::HTTP::NoCachePool do
-  let(:site) { Puppet::Network::HTTP::Site.new('https', 'rubygems.org', 443) }
-  let(:verifier) { double('verifier', :setup_connection => nil) }
-
-  it 'yields a started connection' do
-    http  = double('http', start: nil, finish: nil, started?: true)
-
-    factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http)
-    pool = Puppet::Network::HTTP::NoCachePool.new(factory)
-
-    expect { |b|
-      pool.with_connection(site, verifier, &b)
-    }.to yield_with_args(http)
-  end
-
-  it 'yields a new connection each time' do
-    http1  = double('http1', start: nil, finish: nil, started?: true)
-    http2  = double('http2', start: nil, finish: nil, started?: true)
-
-    factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http1, http2)
-    pool = Puppet::Network::HTTP::NoCachePool.new(factory)
-
-    expect { |b|
-      pool.with_connection(site, verifier, &b)
-    }.to yield_with_args(http1)
-
-    expect { |b|
-      pool.with_connection(site, verifier, &b)
-    }.to yield_with_args(http2)
-  end
-
-  it 'has a close method' do
-    Puppet::Network::HTTP::NoCachePool.new.close
-  end
-
-  it 'logs a deprecation warning' do
-    http  = double('http', start: nil, finish: nil, started?: true)
-
-    factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http)
-    Puppet::Network::HTTP::NoCachePool.new(factory)
-
-    expect(@logs).to include(an_object_having_attributes(level: :warning, message: /Puppet::Network::HTTP::NoCachePool is deprecated/))
-  end
-
-  it 'omits the warning when deprecations are disabled' do
-    Puppet[:disable_warnings] = 'deprecations'
-
-    http  = double('http', start: nil, finish: nil, started?: true)
-
-    factory = Puppet::Network::HTTP::Factory.new
-    allow(factory).to receive(:create_connection).and_return(http)
-    Puppet::Network::HTTP::NoCachePool.new(factory)
-
-    expect(@logs).to eq([])
-  end
-end