puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/file_serving/metadata_spec.rb

@@ -87,7 +87,7 @@ describe Puppet::FileServing::Metadata do
   end
 end
 
-describe Puppet::FileServing::Metadata do
+describe Puppet::FileServing::Metadata, :uses_checksums => true do
   include JSONMatchers
   include PuppetSpec::Files
 
@@ -120,23 +120,23 @@ describe Puppet::FileServing::Metadata do
           metadata.mode.should == 0755
         end
 
-        describe "#checksum" do
-          let(:checksum) { Digest::MD5.hexdigest("some content\n") }
-
-          before :each do
-            File.open(path, "wb") {|f| f.print("some content\n")}
-          end
-
-          it "should default to a checksum of type MD5 with the file's current checksum" do
-            metadata.checksum.should == "{md5}#{checksum}"
-          end
-
-          it "should give a mtime checksum when checksum_type is set" do
-            time = Time.now
-            metadata.checksum_type = "mtime"
-            metadata.expects(:mtime_file).returns(@time)
-            metadata.collect
-            metadata.checksum.should == "{mtime}#{@time}"
+        describe "checksumming" do
+          with_digest_algorithms do
+            before :each do
+              File.open(path, "wb") {|f| f.print(plaintext)}
+            end
+
+            it "should default to a checksum of the proper type with the file's current checksum" do
+              metadata.checksum.should == "{#{digest_algorithm}}#{checksum}"
+            end
+
+            it "should give a mtime checksum when checksum_type is set" do
+              time = Time.now
+              metadata.checksum_type = "mtime"
+              metadata.expects(:mtime_file).returns(@time)
+              metadata.collect
+              metadata.checksum.should == "{mtime}#{@time}"
+            end
           end
         end
 
@@ -226,11 +226,10 @@ describe Puppet::FileServing::Metadata do
         # 'path' is a link that points to 'target'
         let(:path) { tmpfile('file_serving_metadata_link') }
         let(:target) { tmpfile('file_serving_metadata_target') }
-        let(:checksum) { Digest::MD5.hexdigest("some content\n") }
         let(:fmode) { Puppet::FileSystem.lstat(path).mode & 0777 }
 
         before :each do
-          File.open(target, "wb") {|f| f.print("some content\n")}
+          File.open(target, "wb") {|f| f.print('some content')}
           set_mode(0644, target)
 
           Puppet::FileSystem.symlink(target, path)
@@ -250,7 +249,7 @@ describe Puppet::FileServing::Metadata do
       let(:path) { tmpfile('file_serving_metadata_find_file') }
 
       before :each do
-        File.open(path, "wb") {|f| f.print("some content\n")}
+        File.open(path, "wb") {|f| f.print('some content')}
         set_mode(0755, path)
       end
 
@@ -369,64 +368,65 @@ describe Puppet::FileServing::Metadata do
 end
 
 
-describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppet.features.manages_symlinks? do
-  describe "when links are managed" do
-    before do
-      path = "/base/path/my/file"
-      @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
-      stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
-      stub_file = stub(:readlink => "/some/other/path", :lstat => stat)
-      Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
-      Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
-      @checksum = Digest::MD5.hexdigest("some content\n") # Remove these when :managed links are no longer checksumed.
-      @file.stubs(:md5_file).returns(@checksum)           #
-
-      if Puppet.features.microsoft_windows?
-        win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
-          :ftype => 'link', :mode => 0755)
-        Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
+describe Puppet::FileServing::Metadata, " when pointing to a link", :if => Puppet.features.manages_symlinks?, :uses_checksums => true do
+  with_digest_algorithms do
+    describe "when links are managed" do
+      before do
+        path = "/base/path/my/file"
+        @file = Puppet::FileServing::Metadata.new(path, :links => :manage)
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "link", :mode => 0755)
+        stub_file = stub(:readlink => "/some/other/path", :lstat => stat)
+        Puppet::FileSystem.expects(:lstat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).with(path).at_least_once.returns "/some/other/path"
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum) # Remove these when :managed links are no longer checksumed.
+
+        if Puppet.features.microsoft_windows?
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
+            :ftype => 'link', :mode => 0755)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
+        end
+
       end
-    end
 
-    it "should store the destination of the link in :destination if links are :manage" do
-      @file.collect
-      @file.destination.should == "/some/other/path"
-    end
-    pending "should not collect the checksum if links are :manage" do
-      # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
-      @file.collect
-      @file.checksum.should be_nil
-    end
-    it "should collect the checksum if links are :manage" do # see pending note above
-      @file.collect
-      @file.checksum.should == "{md5}#{@checksum}"
+      it "should store the destination of the link in :destination if links are :manage" do
+        @file.collect
+        @file.destination.should == "/some/other/path"
+      end
+      pending "should not collect the checksum if links are :manage" do
+        # We'd like this to be true, but we need to always collect the checksum because in the server/client/server round trip we lose the distintion between manage and follow.
+        @file.collect
+        @file.checksum.should be_nil
+      end
+      it "should collect the checksum if links are :manage" do # see pending note above
+        @file.collect
+        @file.checksum.should == "{#{digest_algorithm}}#{checksum}"
+      end
     end
-  end
 
-  describe "when links are followed" do
-    before do
-      path = "/base/path/my/file"
-      @file = Puppet::FileServing::Metadata.new(path, :links => :follow)
-      stat = stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
-      Puppet::FileSystem.expects(:stat).with(path).at_least_once.returns stat
-      Puppet::FileSystem.expects(:readlink).never
-
-      if Puppet.features.microsoft_windows?
-        win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
-          :ftype => 'file', :mode => 0755)
-        Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
-      end
+    describe "when links are followed" do
+      before do
+        path = "/base/path/my/file"
+        @file = Puppet::FileServing::Metadata.new(path, :links => :follow)
+        stat = stub("stat", :uid => 1, :gid => 2, :ftype => "file", :mode => 0755)
+        Puppet::FileSystem.expects(:stat).with(path).at_least_once.returns stat
+        Puppet::FileSystem.expects(:readlink).never
 
-      @checksum = Digest::MD5.hexdigest("some content\n")
-      @file.stubs(:md5_file).returns(@checksum)
-    end
-    it "should not store the destination of the link in :destination if links are :follow" do
-      @file.collect
-      @file.destination.should be_nil
-    end
-    it "should collect the checksum if links are :follow" do
-      @file.collect
-      @file.checksum.should == "{md5}#{@checksum}"
+        if Puppet.features.microsoft_windows?
+          win_stat = stub('win_stat', :owner => 'snarf', :group => 'thundercats',
+            :ftype => 'file', :mode => 0755)
+          Puppet::FileServing::Metadata::WindowsStat.stubs(:new).returns win_stat
+        end
+
+        @file.stubs("#{digest_algorithm}_file".intern).returns(checksum)
+      end
+      it "should not store the destination of the link in :destination if links are :follow" do
+        @file.collect
+        @file.destination.should be_nil
+      end
+      it "should collect the checksum if links are :follow" do
+        @file.collect
+        @file.checksum.should == "{#{digest_algorithm}}#{checksum}"
+      end
     end
   end
 end

data/spec/unit/forge/module_release_spec.rb

@@ -0,0 +1,131 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'puppet/forge'
+require 'net/http'
+require 'puppet/module_tool'
+
+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(:release) { Puppet::Forge::ModuleRelease.new(ssl_repository, JSON.parse(release_json)) }
+
+  let(:mock_file) {
+    mock_io = StringIO.new
+    mock_io.stubs(:path).returns('/dev/null')
+    mock_io
+  }
+
+  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)
+    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)
+
+      release.prepare
+    end
+  end
+
+  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
+    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)
+
+      release.send(:download, '/v3/files/puppetlabs-stdlib-4.1.0.tar.gz', mock_file)
+    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')
+
+      release.send(:validate_checksum, mock_file, 'bbf919d7ee9d278d2facf39c25578bf8')
+    end
+
+    it 'fails md5 check when invalid' do
+      mock_digest_file_with_md5('ffffffffffffffffffffffffffffffff')
+
+      expect { release.send(:validate_checksum, mock_file, 'bbf919d7ee9d278d2facf39c25578bf8') }.to raise_error(RuntimeError, /did not match expected checksum/)
+    end
+  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)
+
+      release.send(:unpack, mock_file, mock_dir)
+    end
+  end
+end

data/spec/unit/forge/repository_spec.rb

@@ -1,12 +1,14 @@
 # encoding: utf-8
 require 'spec_helper'
 require 'net/http'
-require 'puppet/forge'
+require 'puppet/forge/repository'
+require 'puppet/forge/cache'
+require 'puppet/forge/errors'
 
 describe Puppet::Forge::Repository do
-  let(:consumer_version) { "Test/1.0" }
-  let(:repository) { Puppet::Forge::Repository.new('http://fake.com', consumer_version) }
-  let(:ssl_repository) { Puppet::Forge::Repository.new('https://fake.com', consumer_version) }
+  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) }
 
   it "retrieve accesses the cache" do
     path = '/module/foo.tar.gz'
@@ -16,10 +18,12 @@ describe Puppet::Forge::Repository do
   end
 
   it "retrieve merges forge URI and path specified" do
+    host = 'http://fake.com/test'
     path = '/module/foo.tar.gz'
-    repo_uri = 'http://fake.com/test'
-    repository = Puppet::Forge::Repository.new(repo_uri, consumer_version)
-    repository.cache.expects(:retrieve).with(URI.parse(repo_uri+path))
+    uri  = [ host, path ].join('')
+
+    repository = Puppet::Forge::Repository.new(host, agent)
+    repository.cache.expects(:retrieve).with(uri)
 
     repository.retrieve(path)
   end
@@ -30,7 +34,8 @@ describe Puppet::Forge::Repository do
     end
 
     it "returns the result object from the request" do
-      result = "the http response"
+      result = "#{Object.new}"
+
       performs_an_http_request result do |http|
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
@@ -39,7 +44,7 @@ describe Puppet::Forge::Repository do
     end
 
     it 'returns the result object from a request with ssl' do
-      result = "the http response"
+      result = "#{Object.new}"
       performs_an_https_request result do |http|
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
@@ -48,7 +53,7 @@ describe Puppet::Forge::Repository do
     end
 
     it 'return a valid exception when there is an SSL verification problem' do
-      performs_an_https_request "the http response" do |http|
+      performs_an_https_request "#{Object.new}" do |http|
         http.expects(:request).with(responds_with(:path, "the_path")).raises OpenSSL::SSL::SSLError.new("certificate verify failed")
       end
 
@@ -56,7 +61,7 @@ describe Puppet::Forge::Repository do
     end
 
     it 'return a valid exception when there is a communication problem' do
-      performs_an_http_request "the http response" do |http|
+      performs_an_http_request "#{Object.new}" do |http|
         http.expects(:request).with(responds_with(:path, "the_path")).raises SocketError
       end
 
@@ -66,17 +71,13 @@ describe Puppet::Forge::Repository do
     end
 
     it "sets the user agent for the request" do
-      performs_an_http_request do |http|
-        http.expects(:request).with() do |request|
-          puppet_version = /Puppet\/\d+\..*/
-          os_info = /\(.*\)/
-          ruby_version = /Ruby\/\d+\.\d+\.\d+(-p-?\d+)? \(\d{4}-\d{2}-\d{2}; .*\)/
+      path = 'the_path'
 
-          request["User-Agent"] =~ /^#{consumer_version} #{puppet_version} #{os_info} #{ruby_version}/
-        end
-      end
+      request = repository.get_request_object(path)
 
-      repository.make_http_request("the_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

data/spec/unit/forge_spec.rb

@@ -4,34 +4,110 @@ require 'net/http'
 require 'puppet/module_tool'
 
 describe Puppet::Forge do
-  let(:response_body) do
+  let(:http_response) do
   <<-EOF
-    [
-      {
-        "author": "puppetlabs",
-        "name": "bacula",
-        "tag_list": ["backup", "bacula"],
-        "releases": [{"version": "0.0.1"}, {"version": "0.0.2"}],
-        "full_name": "puppetlabs/bacula",
-        "version": "0.0.2",
-        "project_url": "http://github.com/puppetlabs/puppetlabs-bacula",
-        "desc": "bacula"
-      }
-    ]
+    {
+      "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
   end
 
-  let(:forge) { Puppet::Forge.new("test_agent", SemVer.new("v1.0.0")) }
+  let(:search_results) do
+    JSON.parse(http_response)['results'].map do |hash|
+      hash.merge(
+        "author" => "puppetlabs",
+        "name" => "bacula",
+        "tag_list" => ["backup", "bacula"],
+        "full_name" => "puppetlabs/bacula",
+        "version" => "0.0.2",
+        "project_url" => "https://github.com/puppetlabs/puppetlabs-bacula",
+        "desc" => "bacula"
+      )
+    end
+  end
+
+  let(:forge) { Puppet::Forge.new }
 
   def repository_responds_with(response)
     Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
   end
 
   it "returns a list of matches from the forge when there are matches for the search term" do
-    response = stub(:body => response_body, :code => '200')
-    repository_responds_with(response)
-
-    forge.search('bacula').should == PSON.load(response_body)
+    repository_responds_with(stub(:body => http_response, :code => '200'))
+    forge.search('bacula').should == search_results
   end
 
   context "when the connection to the forge fails" do
@@ -43,18 +119,18 @@ describe Puppet::Forge do
       expect { forge.search('bacula') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'bacula'. Detail: 404 not found."
     end
 
-    it "raises an error for remote_dependency_info" do
-      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: 404 not found."
+    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."
     end
   end
 
-  context "when the API responses with an error" do
+  context "when the API responds with an error" do
     before :each do
       repository_responds_with(stub(:body => '{"error":"invalid module"}', :code => '410', :message => "Gone"))
     end
 
-    it "raises an error for remote_dependency_info" do
-      expect { forge.remote_dependency_info('puppetlabs', 'bacula', '0.0.1') }.to raise_error Puppet::Forge::Errors::ResponseError, "Could not execute operation for 'puppetlabs/bacula'. Detail: invalid module / 410 Gone."
+    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."
     end
   end
 end