puppet 6.11.1-universal-darwin → 6.12.0-universal-darwin

data/spec/unit/forge_spec.rb

@@ -1,88 +1,13 @@
 require 'spec_helper'
-require 'puppet/forge'
+require 'spec_helper'
 require 'net/http'
+require 'puppet/forge'
 require 'puppet/module_tool'
 
 describe Puppet::Forge do
+
   let(:http_response) do
-  <<-EOF
-    {
-      "pagination": {
-        "limit": 1,
-        "offset": 0,
-        "first": "/v3/modules?limit=1&offset=0",
-        "previous": null,
-        "current": "/v3/modules?limit=1&offset=0",
-        "next": null,
-        "total": 1832
-      },
-      "results": [
-        {
-          "uri": "/v3/modules/puppetlabs-bacula",
-          "name": "bacula",
-          "downloads": 640274,
-          "created_at": "2011-05-24 18:34:58 -0700",
-          "updated_at": "2013-12-03 15:24:20 -0800",
-          "owner": {
-            "uri": "/v3/users/puppetlabs",
-            "username": "puppetlabs",
-            "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-          },
-          "current_release": {
-            "uri": "/v3/releases/puppetlabs-bacula-0.0.2",
-            "module": {
-              "uri": "/v3/modules/puppetlabs-bacula",
-              "name": "bacula",
-              "owner": {
-                "uri": "/v3/users/puppetlabs",
-                "username": "puppetlabs",
-                "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-              }
-            },
-            "version": "0.0.2",
-            "metadata": {
-              "types": [],
-              "license": "Apache 2.0",
-              "checksums": { },
-              "version": "0.0.2",
-              "source": "git://github.com/puppetlabs/puppetlabs-bacula.git",
-              "project_page": "https://github.com/puppetlabs/puppetlabs-bacula",
-              "summary": "bacula",
-              "dependencies": [ ],
-              "author": "puppetlabs",
-              "name": "puppetlabs-bacula"
-            },
-            "tags": [
-              "backup",
-              "bacula"
-            ],
-            "file_uri": "/v3/files/puppetlabs-bacula-0.0.2.tar.gz",
-            "file_size": 67586,
-            "file_md5": "bbf919d7ee9d278d2facf39c25578bf8",
-            "downloads": 565041,
-            "readme": "",
-            "changelog": "",
-            "license": "",
-            "created_at": "2013-05-13 08:31:19 -0700",
-            "updated_at": "2013-05-13 08:31:19 -0700",
-            "deleted_at": null
-          },
-          "releases": [
-            {
-              "uri": "/v3/releases/puppetlabs-bacula-0.0.2",
-              "version": "0.0.2"
-            },
-            {
-              "uri": "/v3/releases/puppetlabs-bacula-0.0.1",
-              "version": "0.0.1"
-            }
-          ],
-          "homepage_url": "https://github.com/puppetlabs/puppetlabs-bacula",
-          "issues_url": "https://projects.puppetlabs.com/projects/bacula/issues"
-        }
-      ]
-    }
-  EOF
+    File.read(my_fixture('bacula.json'))
   end
 
   let(:search_results) do
@@ -99,76 +24,84 @@ describe Puppet::Forge do
     end
   end
 
-  let(:forge) { Puppet::Forge.new }
-
-  def repository_responds_with(response, &block)
-    if block_given?
-      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request, &block).and_return(response)
-    else
-      allow_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request).and_return(response)
-    end
+  let(:release_response) do
+    releases = JSON.parse(http_response)
+    releases['results'] = []
+    JSON.dump(releases)
   end
 
+  let(:forge) { Puppet::Forge.new }
+
   it "returns a list of matches from the forge when there are matches for the search term" do
-    repository_responds_with(double(:body => http_response, :code => '200'))
+    stub_request(:get, "https://forgeapi.puppet.com/v3/modules?query=bacula").to_return(status: 200, body: http_response)
+
     expect(forge.search('bacula')).to eq(search_results)
   end
 
   context "when module_groups are defined" do
-    let(:release_response) do
-      releases = JSON.parse(http_response)
-      releases['results'] = []
-      JSON.dump(releases)
-    end
-
     before :each do
-      repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo/}
       Puppet[:module_groups] = "foo"
     end
 
     it "passes module_groups with search" do
+      stub_request(:get, "https://forgeapi.puppet.com/v3/modules")
+        .with(query: hash_including("module_groups" => "foo"))
+        .to_return(status: 200, body: release_response)
+
       forge.search('bacula')
     end
 
     it "passes module_groups with fetch" do
+      stub_request(:get, "https://forgeapi.puppet.com/v3/releases")
+        .with(query: hash_including("module_groups" => "foo"))
+        .to_return(status: 200, body: release_response)
+
       forge.fetch('puppetlabs-bacula')
     end
   end
 
   # See PUP-8008
   context "when multiple module_groups are defined" do
-    let(:release_response) do
-      releases = JSON.parse(http_response)
-      releases['results'] = []
-      JSON.dump(releases)
-    end
-
     context "with space seperator" do
       before :each do
-        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo bar"
       end
 
       it "passes module_groups with search" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/modules}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.search('bacula')
       end
 
       it "passes module_groups with fetch" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/releases}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.fetch('puppetlabs-bacula')
       end
     end
 
     context "with plus seperator" do
       before :each do
-        repository_responds_with(double(:body => release_response, :code => '200')) {|uri| uri =~ /module_groups=foo bar/}
         Puppet[:module_groups] = "foo+bar"
       end
 
       it "passes module_groups with search" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/modules}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.search('bacula')
       end
 
       it "passes module_groups with fetch" do
+        stub_request(:get, %r{forgeapi.puppet.com/v3/releases}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: release_response)
+
         forge.fetch('puppetlabs-bacula')
       end
     end
@@ -176,10 +109,10 @@ describe Puppet::Forge do
     # See PUP-8008
     context "when there are multiple pages of results" do
       before(:each) do
-        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri !=~ /offset/ }.and_return(double(:body => first_page, :code => '200'))
-
-        # Request for second page should not have module_groups already encoded
-        expect_any_instance_of(Puppet::Forge::Repository).to receive(:make_http_request) {|_, uri| uri =~ /module_groups=foo bar/ && uri =~ /offset=1/ }.and_return(double(:body => last_page, :code => '200'))
+        stub_request(:get, %r{forgeapi.puppet.com}).with do |req|
+          expect(req.uri.query).to match(/module_groups=foo%20bar/)
+        end.to_return(status: 200, body: first_page)
+          .to_return(status: 200, body: last_page)
       end
 
       context "with space seperator" do
@@ -242,7 +175,7 @@ describe Puppet::Forge do
 
   context "when the connection to the forge fails" do
     before :each do
-      repository_responds_with(double(:body => '{}', :code => '404', :message => "not found"))
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: [404, 'not found'])
     end
 
     it "raises an error for search" do
@@ -255,25 +188,22 @@ describe Puppet::Forge do
   end
 
   context "when the API responds with an error" do
-    before :each do
-      repository_responds_with(double(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
-    end
-
     it "raises an error for fetch" do
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: [410, 'Gone'], body: '{"error":"invalid module"}')
+
       expect { forge.fetch('puppetlabs/bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Request to Puppet Forge failed. Detail: 410 Gone."
     end
   end
 
   context "when the forge returns a module with unparseable dependencies" do
-    before :each do
+    it "ignores modules with unparseable dependencies" do
       response = JSON.parse(http_response)
       release = response['results'][0]['current_release']
       release['metadata']['dependencies'] = [{'name' => 'broken-garbage >= 1.0.0', 'version_requirement' => 'banana'}]
       response['results'] = [release]
-      repository_responds_with(double(:body => JSON.dump(response), :code => '200'))
-    end
 
-    it "ignores modules with unparseable dependencies" do
+      stub_request(:get, /forgeapi.puppet.com/).to_return(status: 200, body: JSON.dump(response))
+
       expect(forge.fetch('puppetlabs/bacula')).to be_empty
     end
   end

data/spec/unit/functions/find_template_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'puppet_spec/files'
+
+describe 'the find_template function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+  include PuppetSpec::Files
+
+  def with_file_content(content)
+    path = tmpfile('find-file-function')
+    file = File.new(path, 'wb')
+    file.sync = true
+    file.print content
+    yield path
+  end
+
+  it 'finds an existing absolute file when given arguments individually' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template('#{one}', '#{two}'):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'skips non existing files' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template('#{one}/nope', '#{two}'):}")).to have_resource("Notify[#{two}]")
+      end
+    end
+  end
+
+  it 'accepts arguments given as an array' do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        expect(compile_to_catalog("notify { find_template(['#{one}', '#{two}']):}")).to have_resource("Notify[#{one}]")
+      end
+    end
+  end
+
+  it 'finds an existing file in a module' do
+    with_file_content('file content') do |name|
+      mod = double('module')
+      allow(mod).to receive(:template).with('myfile').and_return(name)
+      Puppet[:code] = "notify { find_template('mymod/myfile'):}"
+      node = Puppet::Node.new('localhost')
+      compiler = Puppet::Parser::Compiler.new(node)
+      allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+
+      expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[#{name}]")
+    end
+  end
+
+  it 'returns undef when none of the paths were found' do
+    mod = double('module')
+    allow(mod).to receive(:template).with('myfile').and_return(nil)
+    Puppet[:code] = "notify { String(type(find_template('mymod/myfile', 'nomod/nofile'))):}"
+    node = Puppet::Node.new('localhost')
+    compiler = Puppet::Parser::Compiler.new(node)
+    # For a module that does not have the file
+    allow(compiler.environment).to receive(:module).with('mymod').and_return(mod)
+    # For a module that does not exist
+    allow(compiler.environment).to receive(:module).with('nomod').and_return(nil)
+
+    expect(compiler.compile().filter { |r| r.virtual? }).to have_resource("Notify[Undef]")
+  end
+end

data/spec/unit/http/client_spec.rb

@@ -35,7 +35,15 @@ describe Puppet::HTTP::Client do
 
       expect {
         client.connect(uri)
-      }.to raise_error(Puppet::HTTP::ConnectionError, %r{Failed to connect to https://www.example.com:})
+      }.to raise_error(Puppet::HTTP::ConnectionError, %r{^Request to https://www.example.com failed after .* seconds: (Connection refused|No connection could be made because the target machine actively refused it)})
+    end
+
+    it 'raises ConnectionError if the connect times out' do
+      allow_any_instance_of(Net::HTTP).to receive(:start).and_raise(Net::OpenTimeout)
+
+      expect {
+        client.connect(uri)
+      }.to raise_error(Puppet::HTTP::ConnectionError, %r{^Request to https://www.example.com timed out connect operation after .* seconds})
     end
   end
 
@@ -53,15 +61,15 @@ describe Puppet::HTTP::Client do
     end
 
     it 'raises HTTPError if connection is interrupted while reading' do
-      expect_http_error(EOFError, %r{Request to https://www.example.com interrupted after .* seconds})
+      expect_http_error(EOFError, %r{^Request to https://www.example.com interrupted after .* seconds})
     end
 
     it 'raises HTTPError if connection times out' do
-      expect_http_error(Net::ReadTimeout, %r{Request to https://www.example.com timed out after .* seconds})
+      expect_http_error(Net::ReadTimeout, %r{^Request to https://www.example.com timed out read operation after .* seconds})
     end
 
     it 'raises HTTPError if connection fails' do
-      expect_http_error(ArgumentError, %r{Request to https://www.example.com failed after .* seconds})
+      expect_http_error(ArgumentError, %r{^Request to https://www.example.com failed after .* seconds})
     end
   end
 
@@ -77,7 +85,10 @@ describe Puppet::HTTP::Client do
 
   context "for GET requests" do
     it "includes default HTTP headers" do
-      stub_request(:get, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+      stub_request(:get, uri).with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end
 
       client.get(uri)
     end
@@ -123,9 +134,47 @@ describe Puppet::HTTP::Client do
     end
   end
 
+  context "for HEAD requests" do
+    it "includes default HTTP headers" do
+      stub_request(:head, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      client.head(uri)
+    end
+
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:head, uri).with(query: "foo=bar%3Dbaz")
+
+      client.head(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "merges custom headers with default ones" do
+      stub_request(:head, uri).with(headers: { 'X-Foo' => 'Bar', 'X-Puppet-Version' => /./, 'User-Agent' => /./ })
+
+      client.head(uri, headers: {'X-Foo' => 'Bar'})
+    end
+
+    it "returns the response" do
+      stub_request(:head, uri)
+
+      response = client.head(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:head, uri).to_return(body: "abc")
+
+      expect(client.head(uri).body).to eq("abc")
+    end
+  end
+
   context "for PUT requests" do
     it "includes default HTTP headers" do
-      stub_request(:put, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+      stub_request(:put, uri).with do |request|
+        expect(request.headers).to include({'X-Puppet-Version' => /./, 'User-Agent' => /./})
+        expect(request.headers).to_not include('X-Puppet-Profiling')
+      end
 
       client.put(uri, content_type: 'text/plain', body: "")
     end
@@ -158,6 +207,89 @@ describe Puppet::HTTP::Client do
     end
   end
 
+  context "for POST requests" do
+    it "includes default HTTP headers" do
+      stub_request(:post, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      client.post(uri, content_type: 'text/plain', body: "")
+    end
+
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:post, "https://www.example.com").with(query: "foo=bar%3Dbaz")
+
+      client.post(uri, params: {:foo => "bar=baz"}, content_type: 'text/plain', body: "")
+    end
+
+    it "includes custom headers" do
+      stub_request(:post, "https://www.example.com").with(headers: { 'X-Foo' => 'Bar' })
+
+      client.post(uri, headers: {'X-Foo' => 'Bar'}, content_type: 'text/plain', body: "")
+    end
+
+    it "returns the response" do
+      stub_request(:post, uri)
+
+      response = client.post(uri, content_type: 'text/plain', body: "")
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "sets content-length and content-type for the body" do
+      stub_request(:post, uri).with(headers: {"Content-Length" => "5", "Content-Type" => "text/plain"})
+
+      client.post(uri, content_type: 'text/plain', body: "hello")
+    end
+
+    it "streams the response body when a block is given" do
+      stub_request(:post, uri).to_return(body: "abc")
+
+      io = StringIO.new
+      client.post(uri, content_type: 'text/plain', body: "") do |response|
+        response.read_body do |data|
+          io.write(data)
+        end
+      end
+
+      expect(io.string).to eq("abc")
+    end
+  end
+
+  context "for DELETE requests" do
+    it "includes default HTTP headers" do
+      stub_request(:delete, uri).with(headers: {'X-Puppet-Version' => /./, 'User-Agent' => /./})
+
+      client.delete(uri)
+    end
+
+    it "merges custom headers with default ones" do
+      stub_request(:delete, uri).with(headers: { 'X-Foo' => 'Bar', 'X-Puppet-Version' => /./, 'User-Agent' => /./ })
+
+      client.delete(uri, headers: {'X-Foo' => 'Bar'})
+    end
+
+    it "stringifies keys and encodes values in the query" do
+      stub_request(:delete, "https://www.example.com").with(query: "foo=bar%3Dbaz")
+
+      client.delete(uri, params: {:foo => "bar=baz"})
+    end
+
+    it "returns the response" do
+      stub_request(:delete, uri)
+
+      response = client.delete(uri)
+      expect(response).to be_an_instance_of(Puppet::HTTP::Response)
+      expect(response).to be_success
+      expect(response.code).to eq(200)
+    end
+
+    it "returns the entire response body" do
+      stub_request(:delete, uri).to_return(body: "abc")
+
+      expect(client.delete(uri).body).to eq("abc")
+    end
+  end
+
   context "Basic Auth" do
     it "submits credentials for GET requests" do
       stub_request(:get, uri).with(basic_auth: credentials)