puppet 7.27.0-universal-darwin → 7.29.0-universal-darwin

data/spec/unit/forge/errors_spec.rb

@@ -1,80 +0,0 @@
-require 'spec_helper'
-require 'puppet/forge'
-
-describe Puppet::Forge::Errors do
-  describe 'SSLVerifyError' do
-    subject { Puppet::Forge::Errors::SSLVerifyError }
-    let(:exception) { subject.new(:uri => 'https://fake.com:1111') }
-
-    it 'should return a valid single line error' do
-      expect(exception.message).to eq('Unable to verify the SSL certificate at https://fake.com:1111')
-    end
-
-    it 'should return a valid multiline error' do
-      expect(exception.multiline).to eq <<-EOS.chomp
-Could not connect via HTTPS to https://fake.com:1111
-  Unable to verify the SSL certificate
-    The certificate may not be signed by a valid CA
-    The CA bundle included with OpenSSL may not be valid or up to date
-      EOS
-    end
-  end
-
-  describe 'CommunicationError' do
-    subject { Puppet::Forge::Errors::CommunicationError }
-    let(:socket_exception) { SocketError.new('There was a problem') }
-    let(:exception) { subject.new(:uri => 'http://fake.com:1111', :original => socket_exception) }
-
-    it 'should return a valid single line error' do
-      expect(exception.message).to eq('Unable to connect to the server at http://fake.com:1111. Detail: There was a problem.')
-    end
-
-    it 'should return a valid multiline error' do
-      expect(exception.multiline).to eq <<-EOS.chomp
-Could not connect to http://fake.com:1111
-  There was a network communications problem
-    The error we caught said 'There was a problem'
-    Check your network connection and try again
-      EOS
-    end
-  end
-
-  describe 'ResponseError' do
-    subject { Puppet::Forge::Errors::ResponseError }
-    let(:response) { double(:body => '{}', :code => '404', :reason => "not found") }
-
-    context 'without message' do
-      let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module') }
-
-      it 'should return a valid single line error' do
-        expect(exception.message).to eq('Request to Puppet Forge failed. Detail: 404 not found.')
-      end
-
-      it 'should return a valid multiline error' do
-        expect(exception.multiline).to eq <<-eos.chomp
-Request to Puppet Forge failed.
-  The server being queried was http://fake.com:1111
-  The HTTP response we received was '404 not found'
-        eos
-      end
-    end
-
-    context 'with message' do
-      let(:exception) { subject.new(:uri => 'http://fake.com:1111', :response => response, :input => 'user/module', :message => 'no such module') }
-
-      it 'should return a valid single line error' do
-        expect(exception.message).to eq('Request to Puppet Forge failed. Detail: no such module / 404 not found.')
-      end
-
-      it 'should return a valid multiline error' do
-        expect(exception.multiline).to eq <<-eos.chomp
-Request to Puppet Forge failed.
-  The server being queried was http://fake.com:1111
-  The HTTP response we received was '404 not found'
-  The message we received said 'no such module'
-        eos
-      end
-    end
-  end
-
-end

data/spec/unit/forge/forge_spec.rb

@@ -1,69 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'net/http'
-require 'puppet/forge/repository'
-
-describe Puppet::Forge do
-  before(:all) do
-    # any local http proxy will break these tests
-    ENV['http_proxy'] = nil
-    ENV['HTTP_PROXY'] = nil
-  end
-
-  let(:host) { 'http://fake.com' }
-  let(:forge) { Puppet::Forge.new(host) }
-
-  # different UTF-8 widths
-  # 1-byte A
-  # 2-byte ۿ - http://www.fileformat.info/info/unicode/char/06ff/index.htm - 0xDB 0xBF / 219 191
-  # 3-byte ᚠ - http://www.fileformat.info/info/unicode/char/16A0/index.htm - 0xE1 0x9A 0xA0 / 225 154 160
-  # 4-byte ܎ - http://www.fileformat.info/info/unicode/char/2070E/index.htm - 0xF0 0xA0 0x9C 0x8E / 240 160 156 142
-  let (:mixed_utf8_query_param) { "foo + A\u06FF\u16A0\u{2070E}" } # Aۿᚠ
-  let (:mixed_utf8_query_param_encoded) { "foo%20%2B%20A%DB%BF%E1%9A%A0%F0%A0%9C%8E"}
-  let (:empty_json) { '{ "results": [], "pagination" : { "next" : null } }' }
-
-  describe "making a" do
-    before :each do
-      Puppet[:http_proxy_host] = "proxy"
-      Puppet[:http_proxy_port] = 1234
-    end
-
-    context "search request" do
-      it "includes any defined module_groups, ensuring to only encode them once in the URI" do
-        Puppet[:module_groups] = 'base+pe'
-        encoded_uri = "#{host}/v3/modules?query=#{mixed_utf8_query_param_encoded}&module_groups=base%20pe"
-        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
-
-        forge.search(mixed_utf8_query_param)
-      end
-
-      it "single encodes the search term in the URI" do
-        encoded_uri = "#{host}/v3/modules?query=#{mixed_utf8_query_param_encoded}"
-        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
-
-        forge.search(mixed_utf8_query_param)
-      end
-    end
-
-    context "fetch request" do
-      it "includes any defined module_groups, ensuring to only encode them once in the URI" do
-        Puppet[:module_groups] = 'base+pe'
-        module_name = 'puppetlabs-acl'
-        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
-        encoded_uri = "#{host}/v3/releases?module=#{module_name}&sort_by=version&exclude_fields=#{exclusions}&module_groups=base%20pe"
-        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
-
-        forge.fetch(module_name)
-      end
-
-      it "single encodes the module name term in the URI" do
-        module_name = "puppetlabs-#{mixed_utf8_query_param}"
-        exclusions = "readme%2Cchangelog%2Clicense%2Curi%2Cmodule%2Ctags%2Csupported%2Cfile_size%2Cdownloads%2Ccreated_at%2Cupdated_at%2Cdeleted_at"
-        encoded_uri = "#{host}/v3/releases?module=puppetlabs-#{mixed_utf8_query_param_encoded}&sort_by=version&exclude_fields=#{exclusions}"
-        stub_request(:get, encoded_uri).to_return(status: 200, body: empty_json)
-
-        forge.fetch(module_name)
-      end
-    end
-  end
-end

data/spec/unit/forge/module_release_spec.rb

@@ -1,331 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'puppet/forge'
-require 'net/http'
-require 'puppet/module_tool'
-require 'puppet_spec/files'
-
-describe Puppet::Forge::ModuleRelease do
-  include PuppetSpec::Files
-
-  let(:agent) { "Test/1.0" }
-  let(:repository) { Puppet::Forge::Repository.new('http://fake.com', agent) }
-  let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', agent) }
-  let(:api_version) { "v3" }
-  let(:module_author) { "puppetlabs" }
-  let(:module_name) { "stdlib" }
-  let(:module_version) { "4.1.0" }
-  let(:module_full_name) { "#{module_author}-#{module_name}" }
-  let(:module_full_name_versioned) { "#{module_full_name}-#{module_version}" }
-  let(:module_md5) { "bbf919d7ee9d278d2facf39c25578bf8" }
-  let(:module_sha256) { "b4c6f15cec64a9fe16ef0d291e2598fc84f381bc59f0e67198d61706fafedae4" }
-  let(:uri) { " "}
-  let(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
-
-  let(:mock_file) { double('file', path: '/dev/null') }
-  let(:mock_dir) { tmpdir('dir') }
-
-  let(:destination) { tmpfile('forge_module_release') }
-
-  shared_examples 'a module release' do
-    def mock_digest_file_with_md5(md5)
-      allow(Digest::MD5).to receive(:file).and_return(double(:hexdigest => md5))
-    end
-
-    describe '#tmpfile' do
-      it 'should be opened in binary mode' do
-        allow(Puppet::Forge::Cache).to receive(:base_path).and_return(Dir.tmpdir)
-        expect(release.send(:tmpfile).binmode?).to be_truthy
-      end
-    end
-
-    describe '#download' do
-      it 'should download a file' do
-        stub_request(:get, "https://fake.com/#{api_version}/files/#{module_full_name_versioned}.tar.gz").to_return(status: 200, body: '{}')
-
-        File.open(destination, 'wb') do |fh|
-          release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", fh)
-        end
-
-        expect(File.read(destination)).to eq("{}")
-      end
-
-      it 'should raise a response error when it receives an error from forge' do
-        stub_request(:get, "https://fake.com/some/path").to_return(
-          status: [500, 'server error'],
-          body: '{"error":"invalid module"}'
-        )
-        expect {
-          release.send(:download, "/some/path", StringIO.new)
-        }.to raise_error Puppet::Forge::Errors::ResponseError
-      end
-    end
-
-    describe '#unpack' do
-      it 'should call unpacker with correct params' do
-        expect(Puppet::ModuleTool::Applications::Unpacker).to receive(:unpack).with(mock_file.path, mock_dir).and_return(true)
-
-        release.send(:unpack, mock_file, mock_dir)
-      end
-    end
-  end
-
-  context 'standard forge module' do
-    let(:release_json) do %Q{
-    {
-      "uri": "/#{api_version}/releases/#{module_full_name_versioned}",
-      "module": {
-        "uri": "/#{api_version}/modules/#{module_full_name}",
-        "name": "#{module_name}",
-        "owner": {
-          "uri": "/#{api_version}/users/#{module_author}",
-          "username": "#{module_author}",
-          "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-        }
-      },
-      "version": "#{module_version}",
-      "metadata": {
-        "types": [ ],
-        "license": "Apache 2.0",
-        "checksums": { },
-        "version": "#{module_version}",
-        "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "summary": "Puppet Module Standard Library",
-        "dependencies": [
-
-        ],
-        "author": "#{module_author}",
-        "name": "#{module_full_name}"
-      },
-      "tags": [
-        "puppetlabs",
-        "library",
-        "stdlib",
-        "standard",
-        "stages"
-      ],
-      "file_uri": "/#{api_version}/files/#{module_full_name_versioned}.tar.gz",
-      "file_size": 67586,
-      "file_md5": "#{module_md5}",
-      "file_sha256": "#{module_sha256}",
-      "downloads": 610751,
-      "readme": "",
-      "changelog": "",
-      "license": "",
-      "created_at": "2013-05-13 08:31:19 -0700",
-      "updated_at": "2013-05-13 08:31:19 -0700",
-      "deleted_at": null
-    }
-    }
-    end
-
-    it_behaves_like 'a module release'
-
-    context 'when verifying checksums' do
-      let(:json) { JSON.parse(release_json) }
-
-      def mock_release(json)
-        release = Puppet::Forge::ModuleRelease.new(ssl_repository, json)
-        allow(release).to receive(:tmpfile).and_return(mock_file)
-        allow(release).to receive(:tmpdir).and_return(mock_dir)
-        allow(release).to receive(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
-        allow(release).to receive(:unpack)
-        release
-      end
-
-      it 'verifies using SHA256' do
-        expect(Digest::SHA256).to receive(:file).and_return(double(:hexdigest => module_sha256))
-
-        release = mock_release(json)
-        release.prepare
-      end
-
-      it 'rejects an invalid release with SHA256' do
-        expect(Digest::SHA256).to receive(:file).and_return(double(:hexdigest => 'ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff'))
-
-        release = mock_release(json)
-        expect {
-          release.prepare
-        }.to raise_error(RuntimeError, /did not match expected checksum/)
-      end
-
-      context 'when `file_sha256` is missing' do
-        before(:each) do
-          json.delete('file_sha256')
-        end
-
-        it 'verifies using MD5 if `file_sha256` is missing' do
-          expect(Digest::MD5).to receive(:file).and_return(double(:hexdigest => module_md5))
-
-          release = mock_release(json)
-          release.prepare
-        end
-
-        it 'rejects an invalid release with MD5' do
-          expect(Digest::MD5).to receive(:file).and_return(double(:hexdigest => 'ffffffffffffffffffffffffffffffff'))
-
-          release = mock_release(json)
-          expect {
-            release.prepare
-          }.to raise_error(RuntimeError, /did not match expected checksum/)
-        end
-
-        it 'raises if FIPS is enabled' do
-          allow(Facter).to receive(:value).with(:fips_enabled).and_return(true)
-
-          release = mock_release(json)
-          expect {
-            release.prepare
-          }.to raise_error(/Module install using MD5 is prohibited in FIPS mode./)
-        end
-      end
-    end
-  end
-
-  context 'forge module with no dependencies field' do
-    let(:release_json) do %Q{
-    {
-      "uri": "/#{api_version}/releases/#{module_full_name_versioned}",
-      "module": {
-        "uri": "/#{api_version}/modules/#{module_full_name}",
-        "name": "#{module_name}",
-        "owner": {
-          "uri": "/#{api_version}/users/#{module_author}",
-          "username": "#{module_author}",
-          "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-        }
-      },
-      "version": "#{module_version}",
-      "metadata": {
-        "types": [ ],
-        "license": "Apache 2.0",
-        "checksums": { },
-        "version": "#{module_version}",
-        "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "summary": "Puppet Module Standard Library",
-        "author": "#{module_author}",
-        "name": "#{module_full_name}"
-      },
-      "tags": [
-        "puppetlabs",
-        "library",
-        "stdlib",
-        "standard",
-        "stages"
-      ],
-      "file_uri": "/#{api_version}/files/#{module_full_name_versioned}.tar.gz",
-      "file_size": 67586,
-      "file_md5": "#{module_md5}",
-      "file_sha256": "#{module_sha256}",
-      "downloads": 610751,
-      "readme": "",
-      "changelog": "",
-      "license": "",
-      "created_at": "2013-05-13 08:31:19 -0700",
-      "updated_at": "2013-05-13 08:31:19 -0700",
-      "deleted_at": null
-    }
-    }
-    end
-
-    it_behaves_like 'a module release'
-  end
-
-  context 'forge module with the minimal set of fields' do
-    let(:release_json) do %Q{
-    {
-      "uri": "/#{api_version}/releases/#{module_full_name_versioned}",
-      "module": {
-        "uri": "/#{api_version}/modules/#{module_full_name}",
-        "name": "#{module_name}"
-      },
-      "metadata": {
-        "version": "#{module_version}",
-        "name": "#{module_full_name}"
-      },
-      "file_uri": "/#{api_version}/files/#{module_full_name_versioned}.tar.gz",
-      "file_size": 67586,
-      "file_md5": "#{module_md5}",
-      "file_sha256": "#{module_sha256}"
-    }
-    }
-    end
-
-    it_behaves_like 'a module release'
-  end
-
-  context 'deprecated forge module' do
-    let(:release_json) do %Q{
-    {
-      "uri": "/#{api_version}/releases/#{module_full_name_versioned}",
-      "module": {
-        "uri": "/#{api_version}/modules/#{module_full_name}",
-        "name": "#{module_name}",
-        "deprecated_at": "2017-10-10 10:21:32 -0700",
-        "owner": {
-          "uri": "/#{api_version}/users/#{module_author}",
-          "username": "#{module_author}",
-          "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-        }
-      },
-      "version": "#{module_version}",
-      "metadata": {
-        "types": [ ],
-        "license": "Apache 2.0",
-        "checksums": { },
-        "version": "#{module_version}",
-        "description": "Standard Library for Puppet Modules",
-        "source": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
-        "summary": "Puppet Module Standard Library",
-        "dependencies": [
-
-        ],
-        "author": "#{module_author}",
-        "name": "#{module_full_name}"
-      },
-      "tags": [
-        "puppetlabs",
-        "library",
-        "stdlib",
-        "standard",
-        "stages"
-      ],
-      "file_uri": "/#{api_version}/files/#{module_full_name_versioned}.tar.gz",
-      "file_size": 67586,
-      "file_md5": "#{module_md5}",
-      "file_sha256": "#{module_sha256}",
-      "downloads": 610751,
-      "readme": "",
-      "changelog": "",
-      "license": "",
-      "created_at": "2013-05-13 08:31:19 -0700",
-      "updated_at": "2013-05-13 08:31:19 -0700",
-      "deleted_at": null
-    }
-    }
-    end
-
-    it_behaves_like 'a module release'
-
-    describe '#prepare' do
-      before :each do
-        allow(release).to receive(:tmpfile).and_return(mock_file)
-        allow(release).to receive(:tmpdir).and_return(mock_dir)
-        allow(release).to receive(:download)
-        allow(release).to receive(:validate_checksum)
-        allow(release).to receive(:unpack)
-      end
-
-      it 'should emit warning about module deprecation' do
-        expect(Puppet).to receive(:warning).with(/#{Regexp.escape(module_full_name)}.*deprecated/i)
-
-        release.prepare
-      end
-    end
-  end
-end

data/spec/unit/forge/repository_spec.rb

@@ -1,154 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'net/http'
-require 'puppet/forge/repository'
-require 'puppet/forge/cache'
-require 'puppet/forge/errors'
-
-describe Puppet::Forge::Repository do
-  before(:all) do
-    # any local http proxy will break these tests
-    ENV['http_proxy'] = nil
-    ENV['HTTP_PROXY'] = nil
-  end
-  let(:agent) { "Test/1.0" }
-  let(:repository) { Puppet::Forge::Repository.new('http://fake.com', agent) }
-
-  it "retrieve accesses the cache" do
-    path = '/module/foo.tar.gz'
-    expect(repository.cache).to receive(:retrieve)
-
-    repository.retrieve(path)
-  end
-
-  it "retrieve merges forge URI and path specified" do
-    host = 'http://fake.com/test'
-    path = '/module/foo.tar.gz'
-    uri  = [ host, path ].join('')
-
-    repository = Puppet::Forge::Repository.new(host, agent)
-    expect(repository.cache).to receive(:retrieve).with(uri)
-
-    repository.retrieve(path)
-  end
-
-  describe "making a request" do
-    let(:uri) { "http://fake.com/the_path" }
-
-    it "returns the response object from the request" do
-      stub_request(:get, uri)
-
-      expect(repository.make_http_request("/the_path")).to be_a_kind_of(Puppet::HTTP::Response)
-    end
-
-    it "requires path to have a leading slash" do
-      expect {
-        repository.make_http_request("the_path")
-      }.to raise_error(ArgumentError, 'Path must start with forward slash')
-    end
-
-    it "merges forge URI and path specified" do
-      stub_request(:get, "http://fake.com/test/the_path/")
-
-      repository = Puppet::Forge::Repository.new('http://fake.com/test', agent)
-      repository.make_http_request("/the_path/")
-    end
-
-    it "handles trailing slashes when merging URI and path" do
-      stub_request(:get, "http://fake.com/test/the_path")
-
-      repository = Puppet::Forge::Repository.new('http://fake.com/test/', agent)
-      repository.make_http_request("/the_path")
-    end
-
-    it 'return a valid exception when there is a communication problem' do
-      stub_request(:get, uri).to_raise(SocketError.new('getaddrinfo: Name or service not known'))
-
-      expect {
-        repository.make_http_request("/the_path")
-      }.to raise_error(Puppet::Forge::Errors::CommunicationError,
-                       %r{Unable to connect to the server at http://fake.com. Detail: Request to http://fake.com/the_path failed after .* seconds: getaddrinfo: Name or service not known.})
-    end
-
-    it "sets the user agent for the request" do
-      stub_request(:get, uri).with do |request|
-        expect(request.headers['User-Agent']).to match(/#{agent} #{Regexp.escape(Puppet[:http_user_agent])}/)
-      end
-
-      repository.make_http_request("/the_path")
-    end
-
-    it "does not set Authorization header by default" do
-      allow(Puppet.features).to receive(:pe_license?).and_return(false)
-      Puppet[:forge_authorization] = nil
-
-      stub_request(:get, uri).with do |request|
-        expect(request.headers).to_not include('Authorization')
-      end
-
-      repository.make_http_request("/the_path")
-    end
-
-    it "sets Authorization header from config" do
-      token = 'bearer some token'
-      Puppet[:forge_authorization] = token
-
-      stub_request(:get, uri).with(headers: {'Authorization' => token})
-
-      repository.make_http_request("/the_path")
-    end
-
-    it "sets Authorization header from PE license" do
-      allow(Puppet.features).to receive(:pe_license?).and_return(true)
-      stub_const("PELicense", double(load_license_key: double(authorization_token: "opensesame")))
-
-      stub_request(:get, uri).with(headers: {'Authorization' => "opensesame"})
-
-      repository.make_http_request("/the_path")
-    end
-
-    it "sets basic authentication if there isn't forge authorization or PE license" do
-      stub_request(:get, uri).with(basic_auth: ['user1', 'password'])
-
-      repository = Puppet::Forge::Repository.new('http://user1:password@fake.com', agent)
-      repository.make_http_request("/the_path")
-    end
-
-    it "omits basic authentication if there is a forge authorization" do
-      token = 'bearer some token'
-      Puppet[:forge_authorization] = token
-      stub_request(:get, uri).with(headers: {'Authorization' => token})
-
-      repository = Puppet::Forge::Repository.new('http://user1:password@fake.com', agent)
-      repository.make_http_request("/the_path")
-    end
-
-    it "encodes the URI path" do
-      stub_request(:get, "http://fake.com/h%C3%A9llo%20world%20!!%20%C3%A7%20%C3%A0")
-
-      repository.make_http_request("/héllo world !! ç à")
-    end
-
-    it "connects via proxy" do
-      Puppet[:http_proxy_host] = 'proxy'
-      Puppet[:http_proxy_port] = 1234
-
-      stub_request(:get, uri)
-      expect(Net::HTTP).to receive(:new).with(anything, anything, 'proxy', 1234, nil, nil).and_call_original
-
-      repository.make_http_request("/the_path")
-    end
-
-    it "connects via authenticating proxy" do
-      Puppet[:http_proxy_host] = 'proxy'
-      Puppet[:http_proxy_port] = 1234
-      Puppet[:http_proxy_user] = 'user1'
-      Puppet[:http_proxy_password] = 'password'
-
-      stub_request(:get, uri)
-      expect(Net::HTTP).to receive(:new).with(anything, anything, 'proxy', 1234, "user1", "password").and_call_original
-
-      repository.make_http_request("/the_path")
-    end
-  end
-end