puppet 3.6.2 → 3.7.0

data/spec/unit/forge/module_release_spec.rb

@@ -8,57 +8,14 @@ describe Puppet::Forge::ModuleRelease do
   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(:release_json) do
-  <<-EOF
-  {
-    "uri": "/v3/releases/puppetlabs-stdlib-4.1.0",
-    "module": {
-      "uri": "/v3/modules/puppetlabs-stdlib",
-      "name": "stdlib",
-      "owner": {
-        "uri": "/v3/users/puppetlabs",
-        "username": "puppetlabs",
-        "gravatar_id": "fdd009b7c1ec96e088b389f773e87aec"
-      }
-    },
-    "version": "4.1.0",
-    "metadata": {
-      "types": [ ],
-      "license": "Apache 2.0",
-      "checksums": { },
-      "version": "4.1.0",
-      "description": "Standard Library for Puppet Modules",
-      "source": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
-      "project_page": "https://github.com/puppetlabs/puppetlabs-stdlib",
-      "summary": "Puppet Module Standard Library",
-      "dependencies": [
-
-      ],
-      "author": "puppetlabs",
-      "name": "puppetlabs-stdlib"
-    },
-    "tags": [
-      "puppetlabs",
-      "library",
-      "stdlib",
-      "standard",
-      "stages"
-    ],
-    "file_uri": "/v3/files/puppetlabs-stdlib-4.1.0.tar.gz",
-    "file_size": 67586,
-    "file_md5": "bbf919d7ee9d278d2facf39c25578bf8",
-    "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
-  }
-  EOF
-  end
-
+  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(:uri) { " "}
   let(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
 
   let(:mock_file) {
@@ -69,63 +26,195 @@ describe Puppet::Forge::ModuleRelease do
 
   let(:mock_dir) { '/tmp' }
 
-  def mock_digest_file_with_md5(md5)
-    Digest::MD5.stubs(:file).returns(stub(:hexdigest => md5))
-  end
-
-  describe '#prepare' do
-    before :each do
-      release.stubs(:tmpfile).returns(mock_file)
-      release.stubs(:tmpdir).returns(mock_dir)
+  shared_examples 'a module release' do
+    def mock_digest_file_with_md5(md5)
+      Digest::MD5.stubs(:file).returns(stub(:hexdigest => md5))
     end
 
-    it 'should call sub methods with correct params' do
-      release.expects(:download).with('/v3/files/puppetlabs-stdlib-4.1.0.tar.gz', mock_file)
-      release.expects(:validate_checksum).with(mock_file, 'bbf919d7ee9d278d2facf39c25578bf8')
-      release.expects(:unpack).with(mock_file, mock_dir)
+    describe '#prepare' do
+      before :each do
+        release.stubs(:tmpfile).returns(mock_file)
+        release.stubs(:tmpdir).returns(mock_dir)
+      end
+
+      it 'should call sub methods with correct params' do
+        release.expects(:download).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
+        release.expects(:validate_checksum).with(mock_file, module_md5)
+        release.expects(:unpack).with(mock_file, mock_dir)
 
-      release.prepare
+        release.prepare
+      end
     end
-  end
 
-  describe '#tmpfile' do
+    describe '#tmpfile' do
 
-    # This is impossible to test under Ruby 1.8.x, but should also occur there.
-    it 'should be opened in binary mode', :unless => RUBY_VERSION >= '1.8.7' do
-      Puppet::Forge::Cache.stubs(:base_path).returns(Dir.tmpdir)
-      release.send(:tmpfile).binmode?.should be_true
+      # This is impossible to test under Ruby 1.8.x, but should also occur there.
+      it 'should be opened in binary mode', :unless => RUBY_VERSION >= '1.8.7' do
+        Puppet::Forge::Cache.stubs(:base_path).returns(Dir.tmpdir)
+        release.send(:tmpfile).binmode?.should be_true
+      end
     end
-  end
 
-  describe '#download' do
-    it 'should call make_http_request with correct params' do
-      # valid URI comes from file_uri in JSON blob above
-      ssl_repository.expects(:make_http_request).with('/v3/files/puppetlabs-stdlib-4.1.0.tar.gz', mock_file).returns(mock_file)
+    describe '#download' do
+      it 'should call make_http_request with correct params' do
+        # valid URI comes from file_uri in JSON blob above
+        ssl_repository.expects(:make_http_request).with("/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file).returns(stub(:body => '{}', :code => '200'))
+
+        release.send(:download, "/#{api_version}/files/#{module_full_name_versioned}.tar.gz", mock_file)
+      end
 
-      release.send(:download, '/v3/files/puppetlabs-stdlib-4.1.0.tar.gz', mock_file)
+      it 'should raise a response error when it receives an error from forge' do
+        ssl_repository.stubs(:make_http_request).returns(stub(:body => '{"errors": ["error"]}', :code => '500', :message => 'server error'))
+        expect { release.send(:download, "/some/path", mock_file)}. to raise_error Puppet::Forge::Errors::ResponseError
+      end
     end
-  end
 
-  describe '#verify_checksum' do
-    it 'passes md5 check when valid' do
-      # valid hash comes from file_md5 in JSON blob above
-      mock_digest_file_with_md5('bbf919d7ee9d278d2facf39c25578bf8')
+    describe '#verify_checksum' do
+      it 'passes md5 check when valid' do
+        # valid hash comes from file_md5 in JSON blob above
+        mock_digest_file_with_md5(module_md5)
 
-      release.send(:validate_checksum, mock_file, 'bbf919d7ee9d278d2facf39c25578bf8')
+        release.send(:validate_checksum, mock_file, module_md5)
+      end
+
+      it 'fails md5 check when invalid' do
+        mock_digest_file_with_md5('ffffffffffffffffffffffffffffffff')
+
+        expect { release.send(:validate_checksum, mock_file, module_md5) }.to raise_error(RuntimeError, /did not match expected checksum/)
+      end
     end
 
-    it 'fails md5 check when invalid' do
-      mock_digest_file_with_md5('ffffffffffffffffffffffffffffffff')
+    describe '#unpack' do
+      it 'should call unpacker with correct params' do
+        Puppet::ModuleTool::Applications::Unpacker.expects(:unpack).with(mock_file.path, mock_dir).returns(true)
+
+        release.send(:unpack, mock_file, mock_dir)
+      end
+    end
+  end
 
-      expect { release.send(:validate_checksum, mock_file, 'bbf919d7ee9d278d2facf39c25578bf8') }.to raise_error(RuntimeError, /did not match expected checksum/)
+  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": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "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}",
+      "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
 
-  describe '#unpack' do
-    it 'should call unpacker with correct params' do
-      Puppet::ModuleTool::Applications::Unpacker.expects(:unpack).with(mock_file.path, mock_dir).returns(true)
+  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": "git://github.com/puppetlabs/puppetlabs-stdlib.git",
+        "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}",
+      "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
 
-      release.send(:unpack, mock_file, mock_dir)
+  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}"
+    }
+    }
     end
+
+    it_behaves_like 'a module release'
   end
 end

data/spec/unit/forge/repository_spec.rb

@@ -80,6 +80,20 @@ describe Puppet::Forge::Repository do
       request['User-Agent'].should =~ /\bRuby\b/
     end
 
+    it "Does not set Authorization header by default" do
+      Puppet.features.stubs(:pe_license?).returns(false)
+      Puppet[:forge_authorization] = nil
+      request = repository.get_request_object("the_path")
+      request['Authorization'].should == nil
+    end
+
+    it "Sets Authorization header from config" do
+      token = 'bearer some token'
+      Puppet[:forge_authorization] = token
+      request = repository.get_request_object("the_path")
+      request['Authorization'].should == token
+    end
+
     it "escapes the received URI" do
       unescaped_uri = "héllo world !! ç à"
       performs_an_http_request do |http|
@@ -97,7 +111,7 @@ describe Puppet::Forge::Repository do
       proxy = mock("http proxy")
       proxy_class.expects(:new).with("fake.com", 80).returns(proxy)
       proxy.expects(:start).yields(http).returns(result)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234).returns(proxy_class)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234, nil, nil).returns(proxy_class)
     end
 
     def performs_an_https_request(result = nil, &block)
@@ -111,7 +125,94 @@ describe Puppet::Forge::Repository do
       proxy.expects(:use_ssl=).with(true)
       proxy.expects(:cert_store=)
       proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234).returns(proxy_class)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234, nil, nil).returns(proxy_class)
+    end
+  end
+
+  describe "making a request against an authentiated proxy" do
+    before :each do
+      authenticated_proxy_settings_of("proxy", 1234, 'user1', 'password')
+    end
+
+    it "returns the result object from the request" do
+      result = "#{Object.new}"
+
+      performs_an_authenticated_http_request result do |http|
+        http.expects(:request).with(responds_with(:path, "the_path"))
+      end
+
+      repository.make_http_request("the_path").should == result
+    end
+
+    it 'returns the result object from a request with ssl' do
+      result = "#{Object.new}"
+      performs_an_authenticated_https_request result do |http|
+        http.expects(:request).with(responds_with(:path, "the_path"))
+      end
+
+      ssl_repository.make_http_request("the_path").should == result
+    end
+
+    it 'return a valid exception when there is an SSL verification problem' do
+      performs_an_authenticated_https_request "#{Object.new}" do |http|
+        http.expects(:request).with(responds_with(:path, "the_path")).raises OpenSSL::SSL::SSLError.new("certificate verify failed")
+      end
+
+      expect { ssl_repository.make_http_request("the_path") }.to raise_error Puppet::Forge::Errors::SSLVerifyError, 'Unable to verify the SSL certificate at https://fake.com'
+    end
+
+    it 'return a valid exception when there is a communication problem' do
+      performs_an_authenticated_http_request "#{Object.new}" do |http|
+        http.expects(:request).with(responds_with(:path, "the_path")).raises SocketError
+      end
+
+      expect { repository.make_http_request("the_path") }.
+        to raise_error Puppet::Forge::Errors::CommunicationError,
+        'Unable to connect to the server at http://fake.com. Detail: SocketError.'
+    end
+
+    it "sets the user agent for the request" do
+      path = 'the_path'
+
+      request = repository.get_request_object(path)
+
+      request['User-Agent'].should =~ /\b#{agent}\b/
+      request['User-Agent'].should =~ /\bPuppet\b/
+      request['User-Agent'].should =~ /\bRuby\b/
+    end
+
+    it "escapes the received URI" do
+      unescaped_uri = "héllo world !! ç à"
+      performs_an_authenticated_http_request do |http|
+        http.expects(:request).with(responds_with(:path, URI.escape(unescaped_uri)))
+      end
+
+      repository.make_http_request(unescaped_uri)
+    end
+
+    def performs_an_authenticated_http_request(result = nil, &block)
+      http = mock("http client")
+      yield http
+
+      proxy_class = mock("http proxy class")
+      proxy = mock("http proxy")
+      proxy_class.expects(:new).with("fake.com", 80).returns(proxy)
+      proxy.expects(:start).yields(http).returns(result)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234, "user1", "password").returns(proxy_class)
+    end
+
+    def performs_an_authenticated_https_request(result = nil, &block)
+      http = mock("http client")
+      yield http
+
+      proxy_class = mock("http proxy class")
+      proxy = mock("http proxy")
+      proxy_class.expects(:new).with("fake.com", 443).returns(proxy)
+      proxy.expects(:start).yields(http).returns(result)
+      proxy.expects(:use_ssl=).with(true)
+      proxy.expects(:cert_store=)
+      proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
+      Net::HTTP.expects(:Proxy).with("proxy", 1234, "user1", "password").returns(proxy_class)
     end
   end
 
@@ -119,4 +220,11 @@ describe Puppet::Forge::Repository do
     Puppet[:http_proxy_host] = host
     Puppet[:http_proxy_port] = port
   end
+
+  def authenticated_proxy_settings_of(host, port, user, password)
+    Puppet[:http_proxy_host] = host
+    Puppet[:http_proxy_port] = port
+    Puppet[:http_proxy_user] = user
+    Puppet[:http_proxy_password] = password
+  end
 end

data/spec/unit/forge_spec.rb

@@ -110,17 +110,38 @@ describe Puppet::Forge do
     forge.search('bacula').should == 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(stub(:body => release_response, :code => '200')).with {|uri| uri =~ /module_groups=foo/}
+      Puppet[:module_groups] = "foo"
+    end
+
+    it "passes module_groups with search" do
+      forge.search('bacula')
+    end
+
+    it "passes module_groups with fetch" do
+      forge.fetch('puppetlabs-bacula')
+    end
+  end
+
   context "when the connection to the forge fails" do
     before :each do
       repository_responds_with(stub(:body => '{}', :code => '404', :message => "not found"))
     end
 
     it "raises an error for search" do
-      expect { forge.search('bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'bacula'. Detail: 404 not found."
+      expect { forge.search('bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Request to Puppet Forge failed. Detail: 404 not found."
     end
 
     it "raises an error for fetch" do
-      expect { forge.fetch('puppetlabs/bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: 404 not found."
+      expect { forge.fetch('puppetlabs/bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Request to Puppet Forge failed. Detail: 404 not found."
     end
   end
 
@@ -130,7 +151,22 @@ describe Puppet::Forge do
     end
 
     it "raises an error for fetch" do
-      expect { forge.fetch('puppetlabs/bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: 410 Gone."
+      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
+      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(stub(:body => JSON.dump(response), :code => '200'))
+    end
+
+    it "ignores modules with unparseable dependencies" do
+      expect { result = forge.fetch('puppetlabs/bacula') }.to_not raise_error
+      expect { result.to be_empty }
     end
   end
 end