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

data/spec/unit/face/module/search_spec.rb

@@ -176,7 +176,7 @@ describe "puppet module search" do
       searcher = mock("Searcher")
       options[:module_repository] = "http://forge.example.com"
 
-      Puppet::Forge.expects(:new).with("PMT", subject.version).returns(forge)
+      Puppet::Forge.expects(:new).with().returns(forge)
       Puppet::ModuleTool::Applications::Searcher.expects(:new).with("puppetlabs-apache", forge, has_entries(options)).returns(searcher)
       searcher.expects(:run)
 

data/spec/unit/face/module/uninstall_spec.rb

@@ -3,62 +3,41 @@ require 'puppet/face'
 require 'puppet/module_tool'
 
 describe "puppet module uninstall" do
-  subject { Puppet::Face[:module, :current] }
+  include PuppetSpec::Files
 
-  let(:options) do
-    {}
-  end
-  let(:modulepath) { File.expand_path('/module/path') }
-  let(:environment) do
-    Puppet::Node::Environment.create(:env, [modulepath])
-  end
-  let(:expected_options) do
-    {
-      :target_dir  => modulepath,
-      :environment_instance => environment,
-    }
-  end
+  describe "action" do
+    let(:name)    { 'module-name' }
+    let(:options) { Hash.new }
 
-  describe "option validation" do
-    around(:each) do |example|
-      Puppet.override(:current_environment => environment) do
-        example.run
-      end
-    end
+    it 'should invoke the Uninstaller app' do
+      args = [ name, options ]
 
-    context "without any options" do
-      it "should require a name" do
-        pattern = /wrong number of arguments/
-        expect { subject.uninstall }.to raise_error ArgumentError, pattern
-      end
+      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
 
-      it "should not require any options" do
-        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).once
-        subject.uninstall("puppetlabs-apache")
-      end
+      Puppet::Face[:module, :current].uninstall(name, options)
     end
 
-    it "should accept the --version option" do
-      options[:version] = "1.0.0"
-      expected_options.merge!(:version => '1.0.0')
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
-      subject.uninstall("puppetlabs-apache", options)
-    end
+    context 'slash-separated module name' do
+      let(:name) { 'module/name' }
+
+      it 'should invoke the Uninstaller app' do
+        args = [ 'module-name', options ]
 
-    it "should accept the --force flag" do
-      options[:force] = true
-      expected_options.merge!(:force => true)
-      Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with("puppetlabs-apache", has_entries(expected_options)).once
-      subject.uninstall("puppetlabs-apache", options)
+        Puppet::ModuleTool.expects(:set_option_defaults).with(options)
+        Puppet::ModuleTool::Applications::Uninstaller.expects(:run).with(*args)
+
+        Puppet::Face[:module, :current].uninstall(name, options)
+      end
     end
   end
 
   describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :uninstall }
+    subject { Puppet::Face.find_action(:module, :uninstall) }
 
     its(:summary)     { should =~ /uninstall.*module/im }
     its(:description) { should =~ /uninstall.*module/im }
-    its(:returns)     { should =~ /hash of module objects.*/im }
+    its(:returns)     { should =~ /uninstalled modules/i }
     its(:examples)    { should_not be_empty }
 
     %w{ license copyright summary description returns examples }.each do |doc|

data/spec/unit/face/parser_spec.rb

@@ -14,9 +14,12 @@ describe Puppet::Face[:parser, :current] do
     end
 
     it "validates the configured site manifest when no files are given" do
-      Puppet[:manifest] = file_containing('site.pp', "{ invalid =>")
+      manifest = file_containing('site.pp', "{ invalid =>")
 
-      expect { parser.validate() }.to exit_with(1)
+      configured_environment = Puppet::Node::Environment.create(:default, [], manifest)
+      Puppet.override(:current_environment => configured_environment) do
+        expect { parser.validate() }.to exit_with(1)
+      end
     end
 
     it "validates the given file" do

data/spec/unit/file_bucket/dipper_spec.rb

@@ -5,8 +5,46 @@ require 'pathname'
 
 require 'puppet/file_bucket/dipper'
 require 'puppet/indirector/file_bucket_file/rest'
+require 'puppet/indirector/file_bucket_file/file'
+require 'puppet/util/checksums'
 
-describe Puppet::FileBucket::Dipper do
+shared_examples_for "a restorable file" do
+  let(:dest) { tmpfile('file_bucket_dest') }
+
+  describe "restoring the file" do
+    with_digest_algorithms do
+      it "should restore the file" do
+        request = nil
+
+        klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
+
+        dipper.restore(dest, checksum).should == checksum
+        digest(Puppet::FileSystem.binread(dest)).should == checksum
+
+        request.key.should == "#{digest_algorithm}/#{checksum}"
+        request.server.should == server
+        request.port.should == port
+      end
+
+      it "should skip restoring if existing file has the same checksum" do
+        File.open(dest, 'wb') {|f| f.print(plaintext) }
+
+        dipper.expects(:getfile).never
+        dipper.restore(dest, checksum).should be_nil
+      end
+
+      it "should overwrite existing file if it has different checksum" do
+        klass.any_instance.expects(:find).returns(Puppet::FileBucket::File.new(plaintext))
+
+        File.open(dest, 'wb') {|f| f.print('other contents') }
+
+        dipper.restore(dest, checksum).should == checksum
+      end
+    end
+  end
+end
+
+describe Puppet::FileBucket::Dipper, :uses_checksums => true do
   include PuppetSpec::Files
 
   def make_tmp_file(contents)
@@ -34,118 +72,85 @@ describe Puppet::FileBucket::Dipper do
     lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
   end
 
-  it "should backup files to a local bucket" do
-    Puppet[:bucketdir] = "/non/existent/directory"
-    file_bucket = tmpdir("bucket")
-
-    @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
+  describe "backing up and retrieving local files" do
+    with_digest_algorithms do
+      it "should backup files to a local bucket" do
+        Puppet[:bucketdir] = "/non/existent/directory"
+        file_bucket = tmpdir("bucket")
 
-    file = make_tmp_file("my\r\ncontents")
-    checksum = "f0d7d4e480ad698ed56aeec8b6bd6dea"
-    Digest::MD5.hexdigest("my\r\ncontents").should == checksum
-
-    @dipper.backup(file).should == checksum
-    Puppet::FileSystem.exist?("#{file_bucket}/f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea/contents").should == true
-  end
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
 
-  it "should not backup a file that is already in the bucket" do
-    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
-
-    file = make_tmp_file("my\r\ncontents")
-    checksum = Digest::MD5.hexdigest("my\r\ncontents")
-
-    Puppet::FileBucket::File.indirection.expects(:head).returns true
-    Puppet::FileBucket::File.indirection.expects(:save).never
-    @dipper.backup(file).should == checksum
-  end
+        file = make_tmp_file(plaintext)
+        digest(plaintext).should == checksum
 
-  it "should retrieve files from a local bucket" do
-    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
-
-    checksum = Digest::MD5.hexdigest('my contents')
-
-    request = nil
-
-    Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new('my contents'))
+        @dipper.backup(file).should == checksum
+        Puppet::FileSystem.exist?("#{file_bucket}/#{bucket_dir}/contents").should == true
+      end
 
-    @dipper.getfile(checksum).should == 'my contents'
+      it "should not backup a file that is already in the bucket" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
-    request.key.should == "md5/#{checksum}"
-  end
+        file = make_tmp_file(plaintext)
 
-  it "should backup files to a remote server" do
-    @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+        Puppet::FileBucket::File.indirection.expects(:head).returns true
+        Puppet::FileBucket::File.indirection.expects(:save).never
+        @dipper.backup(file).should == checksum
+      end
 
-    file = make_tmp_file("my\r\ncontents")
-    checksum = Digest::MD5.hexdigest("my\r\ncontents")
+      it "should retrieve files from a local bucket" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
-    real_path = Pathname.new(file).realpath
+        request = nil
 
-    request1 = nil
-    request2 = nil
+        Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new(plaintext))
 
-    Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
-    Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
+        @dipper.getfile(checksum).should == plaintext
 
-    @dipper.backup(file).should == checksum
-    [request1, request2].each do |r|
-      r.server.should == 'puppetmaster'
-      r.port.should == 31337
-      r.key.should == "md5/#{checksum}/#{real_path}"
+        request.key.should == "#{digest_algorithm}/#{checksum}"
+      end
     end
   end
 
-  it "should retrieve files from a remote server" do
-    @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
+  describe "backing up and retrieving remote files" do
+    with_digest_algorithms do
+      it "should backup files to a remote server" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-    checksum = Digest::MD5.hexdigest('my contents')
+        file = make_tmp_file(plaintext)
 
-    request = nil
+        real_path = Pathname.new(file).realpath
 
-    Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new('my contents'))
+        request1 = nil
+        request2 = nil
 
-    @dipper.getfile(checksum).should == "my contents"
-
-    request.server.should == 'puppetmaster'
-    request.port.should == 31337
-    request.key.should == "md5/#{checksum}"
-  end
-
-  describe "#restore" do
-    shared_examples_for "a restorable file" do
-      let(:contents) { "my\ncontents" }
-      let(:md5) { Digest::MD5.hexdigest(contents) }
-      let(:dest) { tmpfile('file_bucket_dest') }
-
-      it "should restore the file" do
-        request = nil
+        Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
+        Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
 
-        klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(contents))
-
-        dipper.restore(dest, md5).should == md5
-        Digest::MD5.hexdigest(Puppet::FileSystem.binread(dest)).should == md5
-
-        request.key.should == "md5/#{md5}"
-        request.server.should == server
-        request.port.should == port
+        @dipper.backup(file).should == checksum
+        [request1, request2].each do |r|
+          r.server.should == 'puppetmaster'
+          r.port.should == 31337
+          r.key.should == "#{digest_algorithm}/#{checksum}/#{real_path}"
+        end
       end
 
-      it "should skip restoring if existing file has the same checksum" do
-        crnl = "my\r\ncontents"
-        File.open(dest, 'wb') {|f| f.print(crnl) }
+      it "should retrieve files from a remote server" do
+        @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-        dipper.expects(:getfile).never
-        dipper.restore(dest, Digest::MD5.hexdigest(crnl)).should be_nil
-      end
+        request = nil
 
-      it "should overwrite existing file if it has different checksum" do
-        klass.any_instance.expects(:find).returns(Puppet::FileBucket::File.new(contents))
+        Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(plaintext))
 
-        File.open(dest, 'wb') {|f| f.print('other contents') }
+        @dipper.getfile(checksum).should == plaintext
 
-        dipper.restore(dest, md5).should == md5
+        request.server.should == 'puppetmaster'
+        request.port.should == 31337
+        request.key.should == "#{digest_algorithm}/#{checksum}"
       end
     end
+  end
+
+  describe "#restore" do
 
     describe "when restoring from a remote server" do
       let(:klass) { Puppet::FileBucketFile::Rest }
@@ -168,3 +173,4 @@ describe Puppet::FileBucket::Dipper do
     end
   end
 end
+

data/spec/unit/file_bucket/file_spec.rb

@@ -1,19 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-
 require 'puppet/file_bucket/file'
-require 'digest/md5'
-require 'digest/sha1'
 
-describe Puppet::FileBucket::File do
+
+describe Puppet::FileBucket::File, :uses_checksums => true do
   include PuppetSpec::Files
 
-  let(:contents) { "file\r\n contents" }
-  let(:digest) { "8b3702ad1aed1ace7e32bde76ffffb2d" }
-  let(:checksum) { "{md5}#{digest}" }
   # this is the default from spec_helper, but it keeps getting reset at odd times
   let(:bucketdir) { Puppet[:bucketdir] = tmpdir('bucket') }
-  let(:destdir) { File.join(bucketdir, "8/b/3/7/0/2/a/d/#{digest}") }
 
   it "defaults to serializing to `:s`" do
     expect(Puppet::FileBucket::File.default_format).to eq(:s)
@@ -23,25 +17,20 @@ describe Puppet::FileBucket::File do
    expect(Puppet::FileBucket::File.supported_formats).to include(:s, :pson)
   end
 
-  it "can make a round trip through `s`" do
-    file = Puppet::FileBucket::File.new(contents)
-
-    tripped = Puppet::FileBucket::File.convert_from(:s, file.render)
-
-    expect(tripped.contents).to eq(contents)
-  end
-
-  it "can make a round trip through `pson`" do
-    file = Puppet::FileBucket::File.new(contents)
-
-    tripped = Puppet::FileBucket::File.convert_from(:pson, file.render(:pson))
-
-    expect(tripped.contents).to eq(contents)
-  end
+  describe "making round trips through network formats" do
+    with_digest_algorithms do
+      it "can make a round trip through `s`" do
+        file = Puppet::FileBucket::File.new(plaintext)
+        tripped = Puppet::FileBucket::File.convert_from(:s, file.render)
+        expect(tripped.contents).to eq(plaintext)
+      end
 
-  it "should raise an error if changing content" do
-    x = Puppet::FileBucket::File.new("first")
-    expect { x.contents = "new" }.to raise_error(NoMethodError, /undefined method .contents=/)
+      it "can make a round trip through `pson`" do
+        file = Puppet::FileBucket::File.new(plaintext)
+        tripped = Puppet::FileBucket::File.convert_from(:pson, file.render(:pson))
+        expect(tripped.contents).to eq(plaintext)
+      end
+    end
   end
 
   it "should require contents to be a string" do
@@ -54,16 +43,15 @@ describe Puppet::FileBucket::File do
     }.to raise_error(ArgumentError, /Unknown option\(s\): crazy_option/)
   end
 
-  it "should set the contents appropriately" do
-    Puppet::FileBucket::File.new(contents).contents.should == contents
-  end
-
-  it "should default to 'md5' as the checksum algorithm if the algorithm is not in the name" do
-    Puppet::FileBucket::File.new(contents).checksum_type.should == "md5"
-  end
+  with_digest_algorithms do
+    it "it uses #{metadata[:digest_algorithm]} as the configured digest algorithm" do
+      file = Puppet::FileBucket::File.new(plaintext)
 
-  it "should calculate the checksum" do
-    Puppet::FileBucket::File.new(contents).checksum.should == checksum
+      file.contents.should == plaintext
+      file.checksum_type.should == digest_algorithm
+      file.checksum.should == "{#{digest_algorithm}}#{checksum}"
+      file.name.should == "#{digest_algorithm}/#{checksum}"
+    end
   end
 
   describe "when using back-ends" do
@@ -76,15 +64,6 @@ describe Puppet::FileBucket::File do
     end
   end
 
-  it "should return a url-ish name" do
-    Puppet::FileBucket::File.new(contents).name.should == "md5/#{digest}"
-  end
-
-  it "should reject a url-ish name with an invalid checksum" do
-    bucket = Puppet::FileBucket::File.new(contents)
-    expect { bucket.name = "sha1/ae548c0cd614fb7885aaa0b6cb191c34/new/path" }.to raise_error(NoMethodError, /undefined method .name=/)
-  end
-
   it "should convert the contents to PSON" do
     Puppet.expects(:deprecation_warning).with('Serializing Puppet::FileBucket::File objects to pson is deprecated.')
     Puppet::FileBucket::File.new("file contents").to_pson.should == '{"contents":"file contents"}'
@@ -94,35 +73,4 @@ describe Puppet::FileBucket::File do
     Puppet.expects(:deprecation_warning).with('Deserializing Puppet::FileBucket::File objects from pson is deprecated. Upgrade to a newer version.')
     Puppet::FileBucket::File.from_pson({"contents"=>"file contents"}).contents.should == "file contents"
   end
-
-  def make_bucketed_file
-    FileUtils.mkdir_p(destdir)
-    File.open("#{destdir}/contents", 'wb') { |f| f.write contents }
-  end
-
-  describe "using the indirector's find method" do
-    it "should return nil if a file doesn't exist" do
-      bucketfile = Puppet::FileBucket::File.indirection.find("md5/#{digest}")
-      bucketfile.should == nil
-    end
-
-    it "should find a filebucket if the file exists" do
-      make_bucketed_file
-      bucketfile = Puppet::FileBucket::File.indirection.find("md5/#{digest}")
-      bucketfile.checksum.should == checksum
-    end
-
-    describe "using RESTish digest notation" do
-      it "should return nil if a file doesn't exist" do
-        bucketfile = Puppet::FileBucket::File.indirection.find("md5/#{digest}")
-        bucketfile.should == nil
-      end
-
-      it "should find a filebucket if the file exists" do
-        make_bucketed_file
-        bucketfile = Puppet::FileBucket::File.indirection.find("md5/#{digest}")
-        bucketfile.checksum.should == checksum
-      end
-    end
-  end
 end