puppet 3.8.7 → 4.0.0

data/spec/unit/type/file/content_spec.rb

@@ -6,11 +6,11 @@ require 'puppet/network/resolver'
 
 describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true do
   include PuppetSpec::Files
+  include_context 'with supported checksum types'
 
   let(:filename) { tmpfile('testfile') }
-
-  let(:catalog) { Puppet::Resource::Catalog.new }
-
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:catalog) { Puppet::Resource::Catalog.new(:test, environment) }
   let(:resource) { Puppet::Type.type(:file).new :path => filename, :catalog => catalog }
 
   before do
@@ -18,26 +18,9 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     described_class.stubs(:standalone?).returns(false)
   end
 
-  describe "when determining the checksum type" do
-    let(:content) { described_class.new(:resource => resource) }
-
-    it "should use the type specified in the source checksum if a source is set" do
-      resource[:source] = File.expand_path("/foo")
-      resource.parameter(:source).expects(:checksum).returns "{md5lite}eh"
-
-      content.checksum_type.should == :md5lite
-    end
-
-    it "should use the type specified by the checksum parameter if no source is set" do
-      resource[:checksum] = :md5lite
-
-      content.checksum_type.should == :md5lite
-    end
-
-    with_digest_algorithms do
-      it "should use the type specified by digest_algorithm by default" do
-        content.checksum_type.should == digest_algorithm.intern
-      end
+  around do |example|
+    Puppet.override(:environments => Puppet::Environments::Static.new(environment)) do
+      example.run
     end
   end
 
@@ -46,7 +29,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
     it "should use the set content if available" do
       content.should = "ehness"
-      content.actual_content.should == "ehness"
+      expect(content.actual_content).to eq("ehness")
     end
 
     it "should not use the content from the source if the source is set" do
@@ -54,7 +37,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
       resource.expects(:parameter).never.with(:source).returns source
 
-      content.actual_content.should be_nil
+      expect(content.actual_content).to be_nil
     end
   end
 
@@ -62,26 +45,24 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     let(:content) { described_class.new(:resource => resource) }
 
     it "should make the actual content available via an attribute" do
-      content.stubs(:checksum_type).returns "md5"
       content.should = "this is some content"
 
-      content.actual_content.should == "this is some content"
+      expect(content.actual_content).to eq("this is some content")
     end
 
     with_digest_algorithms do
       it "should store the checksum as the desired content" do
         d = digest("this is some content")
 
-        content.stubs(:checksum_type).returns digest_algorithm
         content.should = "this is some content"
 
-        content.should.must == "{#{digest_algorithm}}#{d}"
+        expect(content.should).to eq("{#{digest_algorithm}}#{d}")
       end
 
       it "should not checksum 'absent'" do
         content.should = :absent
 
-        content.should.must == :absent
+        expect(content.should).to eq(:absent)
       end
 
       it "should accept a checksum as the desired content" do
@@ -90,14 +71,14 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         string = "{#{digest_algorithm}}#{d}"
         content.should = string
 
-        content.should.must == string
+        expect(content.should).to eq(string)
       end
     end
 
     it "should convert the value to ASCII-8BIT", :if => "".respond_to?(:encode) do
       content.should= "Let's make a \u{2603}"
 
-      content.actual_content.should == "Let's make a \xE2\x98\x83".force_encoding(Encoding::ASCII_8BIT)
+      expect(content.actual_content).to eq("Let's make a \xE2\x98\x83".force_encoding(Encoding::ASCII_8BIT))
     end
   end
 
@@ -107,21 +88,21 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     it "should return :absent if the file does not exist" do
       resource.expects(:stat).returns nil
 
-      content.retrieve.should == :absent
+      expect(content.retrieve).to eq(:absent)
     end
 
     it "should not manage content on directories" do
       stat = mock 'stat', :ftype => "directory"
       resource.expects(:stat).returns stat
 
-      content.retrieve.should be_nil
+      expect(content.retrieve).to be_nil
     end
 
     it "should not manage content on links" do
       stat = mock 'stat', :ftype => "link"
       resource.expects(:stat).returns stat
 
-      content.retrieve.should be_nil
+      expect(content.retrieve).to be_nil
     end
 
     it "should always return the checksum as a string" do
@@ -133,7 +114,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       time = Time.now
       resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
 
-      content.retrieve.should == "{mtime}#{time}"
+      expect(content.retrieve).to eq("{mtime}#{time}")
     end
 
     with_digest_algorithms do
@@ -142,7 +123,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         resource.expects(:stat).returns stat
         resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
 
-        content.retrieve.should == "{#{digest_algorithm}}mysum"
+        expect(content.retrieve).to eq("{#{digest_algorithm}}mysum")
       end
     end
   end
@@ -154,49 +135,52 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       resource[:ensure] = :file
     end
 
-    it "should return true if the resource shouldn't be a regular file" do
-      resource.expects(:should_be_file?).returns false
-      content.should = "foo"
-      content.must be_safe_insync("whatever")
-    end
+    with_digest_algorithms do
+      before(:each) do
+        resource[:checksum] = digest_algorithm
+      end
 
-    it "should warn that no content will be synced to links when ensure is :present" do
-      resource[:ensure] = :present
-      resource[:content] = 'foo'
-      resource.stubs(:should_be_file?).returns false
-      resource.stubs(:stat).returns mock("stat", :ftype => "link")
+      it "should return true if the resource shouldn't be a regular file" do
+        resource.expects(:should_be_file?).returns false
+        content.should = "foo"
+        expect(content).to be_safe_insync("whatever")
+      end
 
-      resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
+      it "should warn that no content will be synced to links when ensure is :present" do
+        resource[:ensure] = :present
+        resource[:content] = 'foo'
+        resource.stubs(:should_be_file?).returns false
+        resource.stubs(:stat).returns mock("stat", :ftype => "link")
 
-      content.insync? :present
-    end
+        resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
 
-    it "should return false if the current content is :absent" do
-      content.should = "foo"
-      content.should_not be_safe_insync(:absent)
-    end
+        content.insync? :present
+      end
+
+      it "should return false if the current content is :absent" do
+        content.should = "foo"
+        expect(content).not_to be_safe_insync(:absent)
+      end
 
-    it "should return false if the file should be a file but is not present" do
-      resource.expects(:should_be_file?).returns true
-      content.should = "foo"
+      it "should return false if the file should be a file but is not present" do
+        resource.expects(:should_be_file?).returns true
+        content.should = "foo"
 
-      content.should_not be_safe_insync(:absent)
-    end
+        expect(content).not_to be_safe_insync(:absent)
+      end
 
-    describe "and the file exists" do
-      with_digest_algorithms do
+      describe "and the file exists" do
         before do
           resource.stubs(:stat).returns mock("stat")
-          resource[:checksum] = digest_algorithm
           content.should = "some content"
         end
 
         it "should return false if the current contents are different from the desired content" do
-          content.should_not be_safe_insync("other content")
+          expect(content).not_to be_safe_insync("other content")
         end
 
         it "should return true if the sum for the current contents is the same as the sum for the desired content" do
-          content.must be_safe_insync("{#{digest_algorithm}}" + digest("some content"))
+          expect(content).to be_safe_insync("{#{digest_algorithm}}" + digest("some content"))
         end
 
         [true, false].product([true, false]).each do |cfg, param|
@@ -211,12 +195,12 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
               it "should display a diff" do
                 content.expects(:diff).returns("my diff").once
                 content.expects(:debug).with("\nmy diff").once
-                content.should_not be_safe_insync("other content")
+                expect(content).not_to be_safe_insync("other content")
               end
             else
               it "should not display a diff" do
                 content.expects(:diff).never
-                content.should_not be_safe_insync("other content")
+                expect(content).not_to be_safe_insync("other content")
               end
             end
           end
@@ -224,6 +208,61 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       end
     end
 
+    SAVED_TIME = Time.now
+    [:ctime, :mtime].each do |time_stat|
+      [["older", SAVED_TIME-1, false], ["same", SAVED_TIME, true], ["newer", SAVED_TIME+1, true]].each do
+        |compare, target_time, success|
+        describe "with #{compare} target #{time_stat} compared to source" do
+          before do
+            resource[:checksum] = time_stat
+            content.should = "{#{time_stat}}#{SAVED_TIME}"
+          end
+
+          it "should return #{success}" do
+            if success
+              expect(content).to be_safe_insync("{#{time_stat}}#{target_time}")
+            else
+              expect(content).not_to be_safe_insync("{#{time_stat}}#{target_time}")
+            end
+          end
+        end
+      end
+
+      describe "with #{time_stat}" do
+        before do
+          resource[:checksum] = time_stat
+        end
+
+        it "should not be insync if trying to create it" do
+          content.should = "{#{time_stat}}#{SAVED_TIME}"
+          expect(content).not_to be_safe_insync(:absent)
+        end
+
+        it "should raise an error if content is not a checksum" do
+          content.should = "some content"
+          expect {
+            content.safe_insync?("{#{time_stat}}#{SAVED_TIME}")
+          }.to raise_error(/Resource with checksum_type #{time_stat} didn't contain a date in/)
+        end
+
+        it "should not be insync even if content is the absent symbol" do
+          content.should = :absent
+          expect(content).not_to be_safe_insync(:absent)
+        end
+
+        it "should warn that no content will be synced to links when ensure is :present" do
+          resource[:ensure] = :present
+          resource[:content] = 'foo'
+          resource.stubs(:should_be_file?).returns false
+          resource.stubs(:stat).returns mock("stat", :ftype => "link")
+
+          resource.expects(:warning).with {|msg| msg =~ /Ensure set to :present but file type is/}
+
+          content.insync? :present
+        end
+      end
+    end
+
     describe "and :replace is false" do
       before do
         resource.stubs(:replace?).returns false
@@ -232,23 +271,43 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
       it "should be insync if the file exists and the content is different" do
         resource.stubs(:stat).returns mock('stat')
 
-        content.must be_safe_insync("whatever")
+        expect(content).to be_safe_insync("whatever")
       end
 
       it "should be insync if the file exists and the content is right" do
         resource.stubs(:stat).returns mock('stat')
 
-        content.must be_safe_insync("something")
+        expect(content).to be_safe_insync("something")
       end
 
       it "should not be insync if the file does not exist" do
         content.should = "foo"
-        content.should_not be_safe_insync(:absent)
+        expect(content).not_to be_safe_insync(:absent)
+      end
+    end
+  end
+
+  describe "when testing whether the content is initialized in the resource and in sync" do
+    CHECKSUM_TYPES_TO_TRY.each do |checksum_type, checksum|
+      describe "sync with checksum type #{checksum_type} and the file exists" do
+        before do
+          @new_resource = Puppet::Type.type(:file).new :ensure => :file, :path => filename, :catalog => catalog,
+            :content => CHECKSUM_PLAINTEXT, :checksum => checksum_type
+          @new_resource.stubs(:stat).returns mock('stat')
+        end
+
+        it "should return false if the sum for the current contents are different from the desired content" do
+          expect(@new_resource.parameters[:content]).not_to be_safe_insync("other content")
+        end
+
+        it "should return true if the sum for the current contents is the same as the sum for the desired content" do
+          expect(@new_resource.parameters[:content]).to be_safe_insync("{#{checksum_type}}#{checksum}")
+        end
       end
     end
   end
 
- describe "when changing the content" do
+  describe "when changing the content" do
     let(:content) { described_class.new(:resource => resource) }
 
     before do
@@ -265,13 +324,13 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     it "should return :file_changed if the file already existed" do
       resource.expects(:stat).returns "something"
       resource.stubs(:write)
-      content.sync.should == :file_changed
+      expect(content.sync).to eq(:file_changed)
     end
 
     it "should return :file_created if the file did not exist" do
       resource.expects(:stat).returns nil
       resource.stubs(:write)
-      content.sync.should == :file_created
+      expect(content.sync).to eq(:file_created)
     end
   end
 
@@ -300,7 +359,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
 
       it "should return the current checksum value" do
         resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
-        content.write(fh).should == "checksum"
+        expect(content.write(fh)).to eq("checksum")
       end
     end
 
@@ -349,14 +408,14 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         source = resource.parameter(:source)
         resource.write(source)
 
-        Puppet::FileSystem.binread(filename).should == source_content
+        expect(Puppet::FileSystem.binread(filename)).to eq(source_content)
       end
 
       with_digest_algorithms do
         it "should return the checksum computed" do
           File.open(filename, 'wb') do |file|
             resource[:checksum] = digest_algorithm
-            content.write(file).should == "{#{digest_algorithm}}#{digest(source_content)}"
+            expect(content.write(file)).to eq("{#{digest_algorithm}}#{digest(source_content)}")
           end
         end
       end
@@ -400,7 +459,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         source.stubs(:metadata).returns stub_everything('metadata', :source => 'puppet:///test/foo bar', :ftype => 'file')
 
         conn.unstub(:request_get)
-        conn.expects(:request_get).with('/none/file_content/test/foo%20bar', anything).yields(response)
+        conn.expects(:request_get).with("#{Puppet::Network::HTTP::MASTER_URL_PREFIX}/v3/file_content/test/foo%20bar?environment=testing&", anything).yields(response)
 
         resource.write(source)
       end
@@ -452,7 +511,7 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
     describe "each_chunk_from should work" do
 
       it "when content is a string" do
-        content.each_chunk_from('i_am_a_string') { |chunk| chunk.should == 'i_am_a_string' }
+        content.each_chunk_from('i_am_a_string') { |chunk| expect(chunk).to eq('i_am_a_string') }
       end
 
       # The following manifest is a case where source and content.should are both set
@@ -466,50 +525,50 @@ describe Puppet::Type.type(:file).attrclass(:content), :uses_checksums => true d
         content.should = "{md5}123abcd"
 
         content.expects(:chunk_file_from_source).returns('from_source')
-        content.each_chunk_from(source) { |chunk| chunk.should == 'from_source' }
+        content.each_chunk_from(source) { |chunk| expect(chunk).to eq('from_source') }
       end
 
       it "when no content, source, but ensure present" do
         resource[:ensure] = :present
-        content.each_chunk_from(nil) { |chunk| chunk.should == '' }
+        content.each_chunk_from(nil) { |chunk| expect(chunk).to eq('') }
       end
 
       # you might do this if you were just auditing
       it "when no content, source, but ensure file" do
         resource[:ensure] = :file
-        content.each_chunk_from(nil) { |chunk| chunk.should == '' }
+        content.each_chunk_from(nil) { |chunk| expect(chunk).to eq('') }
       end
 
       it "when source_or_content is nil and content not a checksum" do
-        content.each_chunk_from(nil) { |chunk| chunk.should == '' }
+        content.each_chunk_from(nil) { |chunk| expect(chunk).to eq('') }
       end
 
       # the content is munged so that if it's a checksum nil gets passed in
       it "when content is a checksum it should try to read from filebucket" do
         content.should = "{md5}123abcd"
         content.expects(:read_file_from_filebucket).once.returns('im_a_filebucket')
-        content.each_chunk_from(nil) { |chunk| chunk.should == 'im_a_filebucket' }
+        content.each_chunk_from(nil) { |chunk| expect(chunk).to eq('im_a_filebucket') }
       end
 
       it "when running as puppet apply" do
         Puppet[:default_file_terminus] = "file_server"
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:content).once.returns :whoo
-        content.each_chunk_from(source_or_content) { |chunk| chunk.should == :whoo }
+        content.each_chunk_from(source_or_content) { |chunk| expect(chunk).to eq(:whoo) }
       end
 
       it "when running from source with a local file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns true
         content.expects(:chunk_file_from_disk).with(source_or_content).once.yields 'woot'
-        content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
+        content.each_chunk_from(source_or_content) { |chunk| expect(chunk).to eq('woot') }
       end
 
       it "when running from source with a remote file" do
         source_or_content = stubs('source_or_content')
         source_or_content.expects(:local?).returns false
         content.expects(:chunk_file_from_source).with(source_or_content).once.yields 'woot'
-        content.each_chunk_from(source_or_content) { |chunk| chunk.should == 'woot' }
+        content.each_chunk_from(source_or_content) { |chunk| expect(chunk).to eq('woot') }
       end
     end
   end

data/spec/unit/type/file/ctime_spec.rb

@@ -16,19 +16,19 @@ describe Puppet::Type.type(:file).attrclass(:ctime) do
     @resource[:audit] = [:ctime]
 
     # this .to_resource audit behavior is magical :-(
-    @resource.to_resource[:ctime].should == Puppet::FileSystem.stat(@filename).ctime
+    expect(@resource.to_resource[:ctime]).to eq(Puppet::FileSystem.stat(@filename).ctime)
   end
 
   it "should return absent if auditing an absent file" do
     @resource[:audit] = [:ctime]
 
-    @resource.to_resource[:ctime].should == :absent
+    expect(@resource.to_resource[:ctime]).to eq(:absent)
   end
 
   it "should prevent the user from trying to set the ctime" do
-    lambda {
+    expect {
       @resource[:ctime] = Time.now.to_s
-    }.should raise_error(Puppet::Error, /ctime is read-only/)
+    }.to raise_error(Puppet::Error, /ctime is read-only/)
   end
 
 end

data/spec/unit/type/file/ensure_spec.rb

@@ -10,21 +10,21 @@ describe Puppet::Type::File::Ensure do
   let(:property) { resource.property(:ensure) }
 
   it "should be a subclass of Ensure" do
-    described_class.superclass.must == Puppet::Property::Ensure
+    expect(described_class.superclass).to eq(Puppet::Property::Ensure)
   end
 
   describe "when retrieving the current state" do
     it "should return :absent if the file does not exist" do
       resource.expects(:stat).returns nil
 
-      property.retrieve.should == :absent
+      expect(property.retrieve).to eq(:absent)
     end
 
     it "should return the current file type if the file exists" do
       stat = mock 'stat', :ftype => "directory"
       resource.expects(:stat).returns stat
 
-      property.retrieve.should == :directory
+      expect(property.retrieve).to eq(:directory)
     end
   end
 
@@ -32,43 +32,43 @@ describe Puppet::Type::File::Ensure do
     it "should always be in sync if replace is 'false' unless the file is missing" do
       property.should = :file
       resource.expects(:replace?).returns false
-      property.safe_insync?(:link).should be_true
+      expect(property.safe_insync?(:link)).to be_truthy
     end
 
     it "should be in sync if :ensure is set to :absent and the file does not exist" do
       property.should = :absent
 
-      property.must be_safe_insync(:absent)
+      expect(property).to be_safe_insync(:absent)
     end
 
     it "should not be in sync if :ensure is set to :absent and the file exists" do
       property.should = :absent
 
-      property.should_not be_safe_insync(:file)
+      expect(property).not_to be_safe_insync(:file)
     end
 
     it "should be in sync if a normal file exists and :ensure is set to :present" do
       property.should = :present
 
-      property.must be_safe_insync(:file)
+      expect(property).to be_safe_insync(:file)
     end
 
     it "should be in sync if a directory exists and :ensure is set to :present" do
       property.should = :present
 
-      property.must be_safe_insync(:directory)
+      expect(property).to be_safe_insync(:directory)
     end
 
     it "should be in sync if a symlink exists and :ensure is set to :present" do
       property.should = :present
 
-      property.must be_safe_insync(:link)
+      expect(property).to be_safe_insync(:link)
     end
 
     it "should not be in sync if :ensure is set to :file and a directory exists" do
       property.should = :file
 
-      property.should_not be_safe_insync(:directory)
+      expect(property).not_to be_safe_insync(:directory)
     end
   end
 
@@ -88,7 +88,7 @@ describe Puppet::Type::File::Ensure do
       end
 
       it "should accept octal mode as fixnum" do
-        resource[:mode] = 0700
+        resource[:mode] = '0700'
         resource.expects(:property_fix)
         Dir.expects(:mkdir).with(path, 0700)
 

data/spec/unit/type/file/group_spec.rb

@@ -30,15 +30,15 @@ describe Puppet::Type.type(:file).attrclass(:group) do
     end
 
     it "should use the id for comparisons, not the name" do
-      group.insync?('foos').should be_false
+      expect(group.insync?('foos')).to be_falsey
     end
 
     it "should return true if the current group is one of the desired group" do
-      group.insync?(1001).should be_true
+      expect(group.insync?(1001)).to be_truthy
     end
 
     it "should return false if the current group is not one of the desired group" do
-      group.insync?(1003).should be_false
+      expect(group.insync?(1003)).to be_falsey
     end
   end
 
@@ -47,13 +47,13 @@ describe Puppet::Type.type(:file).attrclass(:group) do
       it "should use the name of the user if it can find it" do
         resource.provider.stubs(:gid2name).with(1001).returns 'foos'
 
-        group.send(prop_to_s, 1001).should == 'foos'
+        expect(group.send(prop_to_s, 1001)).to eq('foos')
       end
 
       it "should use the id of the user if it can't" do
         resource.provider.stubs(:gid2name).with(1001).returns nil
 
-        group.send(prop_to_s, 1001).should == 1001
+        expect(group.send(prop_to_s, 1001)).to eq(1001)
       end
     end
   end