puppet 4.4.0-universal-darwin

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

@@ -0,0 +1,85 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+checksum = Puppet::Type.type(:file).attrclass(:checksum)
+describe checksum do
+  before do
+    @path = Puppet.features.microsoft_windows? ? "c:/foo/bar" : "/foo/bar"
+    @resource = Puppet::Type.type(:file).new :path => @path
+    @checksum = @resource.parameter(:checksum)
+  end
+
+  it "should be a parameter" do
+    expect(checksum.superclass).to eq(Puppet::Parameter)
+  end
+
+  it "should use its current value when asked to sum content" do
+    @checksum.value = :md5lite
+    @checksum.expects(:md5lite).with("foobar").returns "yay"
+    @checksum.sum("foobar")
+  end
+
+  it "should use :md5 to sum when no value is set" do
+    @checksum.expects(:md5).with("foobar").returns "yay"
+    @checksum.sum("foobar")
+  end
+
+  it "should return the summed contents with a checksum label" do
+    sum = Digest::MD5.hexdigest("foobar")
+    @resource[:checksum] = :md5
+    expect(@checksum.sum("foobar")).to eq("{md5}#{sum}")
+  end
+
+  it "when using digest_algorithm 'sha256' should return the summed contents with a checksum label" do
+    sum = Digest::SHA256.hexdigest("foobar")
+    @resource[:checksum] = :sha256
+    expect(@checksum.sum("foobar")).to eq("{sha256}#{sum}")
+  end
+
+  it "should use :md5 as its default type" do
+    expect(@checksum.default).to eq(:md5)
+  end
+
+  it "should use its current value when asked to sum a file's content" do
+    @checksum.value = :md5lite
+    @checksum.expects(:md5lite_file).with(@path).returns "yay"
+    @checksum.sum_file(@path)
+  end
+
+  it "should use :md5 to sum a file when no value is set" do
+    @checksum.expects(:md5_file).with(@path).returns "yay"
+    @checksum.sum_file(@path)
+  end
+
+  it "should convert all sums to strings when summing files" do
+    @checksum.value = :mtime
+    @checksum.expects(:mtime_file).with(@path).returns Time.now
+    expect { @checksum.sum_file(@path) }.not_to raise_error
+  end
+
+  it "should return the summed contents of a file with a checksum label" do
+    @resource[:checksum] = :md5
+    @checksum.expects(:md5_file).returns "mysum"
+    expect(@checksum.sum_file(@path)).to eq("{md5}mysum")
+  end
+
+  it "should return the summed contents of a stream with a checksum label" do
+    @resource[:checksum] = :md5
+    @checksum.expects(:md5_stream).returns "mysum"
+    expect(@checksum.sum_stream).to eq("{md5}mysum")
+  end
+
+  it "should yield the sum_stream block to the underlying checksum" do
+    @resource[:checksum] = :md5
+    @checksum.expects(:md5_stream).yields("something").returns("mysum")
+    @checksum.sum_stream do |sum|
+      expect(sum).to eq("something")
+    end
+  end
+
+  it 'should use values allowed by the supported_checksum_types setting' do
+    values = checksum.value_collection.values.reject {|v| v == :none}.map {|v| v.to_s}
+    Puppet.settings[:supported_checksum_types] = values
+    expect(Puppet.settings[:supported_checksum_types]).to eq(values)
+  end
+end

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

@@ -0,0 +1,286 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+describe Puppet::Type.type(:file).attrclass(:checksum_value), :uses_checksums => true do
+  include PuppetSpec::Files
+  include_context 'with supported checksum types'
+
+  let(:path) { tmpfile('foo_bar') }
+  let(:source_file) { file_containing('temp_foo', 'nothing at all') }
+  let(:environment) { Puppet::Node::Environment.create(:testing, []) }
+  let(:catalog) { Puppet::Resource::Catalog.new(:test, environment) }
+  let(:resource) { Puppet::Type.type(:file).new(:path => path, :catalog => catalog) }
+
+  it "should be a property" do
+    expect(described_class.superclass).to eq(Puppet::Property)
+  end
+
+  describe "when retrieving the current checksum_value" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    it "should not compute a checksum if source is absent" do
+      resource.expects(:stat).never
+      expect(checksum_value.retrieve).to be_nil
+    end
+
+    describe "when using a source" do
+      before do
+        resource[:source] = source_file
+      end
+
+      it "should return :absent if the target does not exist" do
+        resource.expects(:stat).returns nil
+
+        expect(checksum_value.retrieve).to eq(:absent)
+      end
+
+      it "should not manage content on directories" do
+        stat = mock 'stat', :ftype => "directory"
+        resource.expects(:stat).returns stat
+
+        expect(checksum_value.retrieve).to be_nil
+      end
+
+      it "should not manage content on links" do
+        stat = mock 'stat', :ftype => "link"
+        resource.expects(:stat).returns stat
+
+        expect(checksum_value.retrieve).to be_nil
+      end
+
+      it "should always return the checksum as a string" do
+        resource[:checksum] = :mtime
+
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+
+        time = Time.now
+        resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
+
+        expect(checksum_value.retrieve).to eq(time.to_s)
+      end
+    end
+
+    with_digest_algorithms do
+      it "should return the checksum of the target if it exists and is a normal file" do
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
+        resource[:source] = source_file
+
+        expect(checksum_value.retrieve).to eq("mysum")
+      end
+    end
+  end
+
+  describe "when testing whether the checksum_value is in sync" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    before do
+      resource[:ensure] = :file
+    end
+
+    it "should return true if source is not specified" do
+      checksum_value.should = "foo"
+      expect(checksum_value).to be_safe_insync("whatever")
+    end
+
+    describe "when a source is provided" do
+      before do
+        resource[:source] = source_file
+      end
+
+      with_digest_algorithms do
+        before(:each) do
+          resource[:checksum] = digest_algorithm
+        end
+
+        it "should return true if the resource shouldn't be a regular file" do
+          resource.expects(:should_be_file?).returns false
+          checksum_value.should = "foo"
+          expect(checksum_value).to be_safe_insync("whatever")
+        end
+
+        it "should return false if the current checksum_value is :absent" do
+          checksum_value.should = "foo"
+          expect(checksum_value).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
+          checksum_value.should = "foo"
+
+          expect(checksum_value).not_to be_safe_insync(:absent)
+        end
+
+        describe "and the file exists" do
+          before do
+            resource.stubs(:stat).returns mock("stat")
+            checksum_value.should = "somechecksum"
+          end
+
+          it "should return false if the current checksum_value is different from the desired checksum_value" do
+            expect(checksum_value).not_to be_safe_insync("otherchecksum")
+          end
+
+          it "should return true if the current checksum_value is the same as the desired checksum_value" do
+            expect(checksum_value).to be_safe_insync("somechecksum")
+          end
+
+          it "should include the diff module" do
+            expect(checksum_value.respond_to?("diff")).to eq(false)
+          end
+
+          [true, false].product([true, false]).each do |cfg, param|
+            describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
+              before do
+                Puppet[:show_diff] = cfg
+                resource.stubs(:show_diff?).returns param
+                resource[:loglevel] = "debug"
+              end
+
+              if cfg and param
+                it "should display a diff" do
+                  checksum_value.expects(:diff).returns("my diff").once
+                  checksum_value.expects(:debug).with("\nmy diff").once
+                  expect(checksum_value).not_to be_safe_insync("otherchecksum")
+                end
+              else
+                it "should not display a diff" do
+                  checksum_value.expects(:diff).never
+                  expect(checksum_value).not_to be_safe_insync("otherchecksum")
+                end
+              end
+            end
+          end
+        end
+      end
+
+      let(:saved_time) { Time.now }
+      [:ctime, :mtime].each do |time_stat|
+        [["older", -1, false], ["same", 0, true], ["newer", 1, true]].each do
+          |compare, target_time, success|
+          describe "with #{compare} target #{time_stat} compared to source" do
+            before do
+              resource[:checksum] = time_stat
+              checksum_value.should = saved_time.to_s
+            end
+
+            it "should return #{success}" do
+              if success
+                expect(checksum_value).to be_safe_insync((saved_time+target_time).to_s)
+              else
+                expect(checksum_value).not_to be_safe_insync((saved_time+target_time).to_s)
+              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
+            checksum_value.should = saved_time.to_s
+            expect(checksum_value).not_to be_safe_insync(:absent)
+          end
+
+          it "should raise an error if checksum_value is not a checksum" do
+            checksum_value.should = "some content"
+            expect {
+              checksum_value.safe_insync?(saved_time.to_s)
+            }.to raise_error(/Resource with checksum_type #{time_stat} didn't contain a date in/)
+          end
+
+          it "should not be insync even if checksum_value is the absent symbol" do
+            checksum_value.should = :absent
+            expect(checksum_value).not_to be_safe_insync(:absent)
+          end
+        end
+      end
+
+      describe "and :replace is false" do
+        before do
+          resource.stubs(:replace?).returns false
+        end
+
+        it "should be insync if the file exists and the checksum_value is different" do
+          resource.stubs(:stat).returns mock('stat')
+
+          expect(checksum_value).to be_safe_insync("whatever")
+        end
+
+        it "should be insync if the file exists and the checksum_value is right" do
+          resource.stubs(:stat).returns mock('stat')
+
+          expect(checksum_value).to be_safe_insync("something")
+        end
+
+        it "should not be insync if the file does not exist" do
+          checksum_value.should = "foo"
+          expect(checksum_value).not_to be_safe_insync(:absent)
+        end
+      end
+    end
+  end
+
+  describe "when testing whether the checksum_value 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 => path, :catalog => catalog,
+            :checksum_value => checksum, :checksum => checksum_type, :source => source_file
+          @new_resource.stubs(:stat).returns mock('stat')
+        end
+
+        it "should return false if the current checksum_value is different from the desired checksum_value" do
+          expect(@new_resource.parameters[:checksum_value]).not_to be_safe_insync("abcdef")
+        end
+
+        it "should return true if the current checksum_value is the same as the desired checksum_value" do
+          expect(@new_resource.parameters[:checksum_value]).to be_safe_insync(checksum)
+        end
+      end
+    end
+  end
+
+  describe "when changing the checksum_value" do
+    let(:checksum_value) { described_class.new(:resource => resource) }
+
+    before do
+      resource.stubs(:[]).with(:path).returns "/boo"
+      resource.stubs(:stat).returns "eh"
+    end
+
+    it "should raise if source is absent" do
+      resource.expects(:write).never
+
+      expect { checksum_value.sync }.to raise_error "checksum_value#sync should not be called without a source parameter"
+    end
+
+    describe "when using a source" do
+      before do
+        resource[:source] = source_file
+      end
+
+      it "should use the file's :write method to write the checksum_value" do
+        resource.expects(:write).with(resource.parameter(:source))
+
+        checksum_value.sync
+      end
+
+      it "should return :file_changed if the file already existed" do
+        resource.expects(:stat).returns "something"
+        resource.stubs(:write)
+        expect(checksum_value.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)
+        expect(checksum_value.sync).to eq(:file_created)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,394 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+
+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(: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
+    File.open(filename, 'w') {|f| f.write "initial file content"}
+    described_class.stubs(:standalone?).returns(false)
+  end
+
+  around do |example|
+    Puppet.override(:environments => Puppet::Environments::Static.new(environment)) do
+      example.run
+    end
+  end
+
+  describe "when determining the actual content to write" do
+    let(:content) { described_class.new(:resource => resource) }
+
+    it "should use the set content if available" do
+      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
+      source = mock 'source'
+
+      resource.expects(:parameter).never.with(:source).returns source
+
+      expect(content.actual_content).to be_nil
+    end
+  end
+
+  describe "when setting the desired content" do
+    let(:content) { described_class.new(:resource => resource) }
+
+    it "should make the actual content available via an attribute" do
+      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.should = "this is some content"
+
+        expect(content.should).to eq("{#{digest_algorithm}}#{d}")
+      end
+
+      it "should not checksum 'absent'" do
+        content.should = :absent
+
+        expect(content.should).to eq(:absent)
+      end
+
+      it "should accept a checksum as the desired content" do
+        d = digest("this is some content")
+
+        string = "{#{digest_algorithm}}#{d}"
+        content.should = 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}"
+
+      expect(content.actual_content).to eq("Let's make a \xE2\x98\x83".force_encoding(Encoding::ASCII_8BIT))
+    end
+  end
+
+  describe "when retrieving the current content" do
+    let(:content) { described_class.new(:resource => resource) }
+
+    it "should return :absent if the file does not exist" do
+      resource.expects(:stat).returns nil
+
+      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
+
+      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
+
+      expect(content.retrieve).to be_nil
+    end
+
+    it "should always return the checksum as a string" do
+      resource[:checksum] = :mtime
+
+      stat = mock 'stat', :ftype => "file"
+      resource.expects(:stat).returns stat
+
+      time = Time.now
+      resource.parameter(:checksum).expects(:mtime_file).with(resource[:path]).returns time
+
+      expect(content.retrieve).to eq("{mtime}#{time}")
+    end
+
+    with_digest_algorithms do
+      it "should return the checksum of the file if it exists and is a normal file" do
+        stat = mock 'stat', :ftype => "file"
+        resource.expects(:stat).returns stat
+        resource.parameter(:checksum).expects("#{digest_algorithm}_file".intern).with(resource[:path]).returns "mysum"
+
+        expect(content.retrieve).to eq("{#{digest_algorithm}}mysum")
+      end
+    end
+  end
+
+  describe "when testing whether the content is in sync" do
+    let(:content) { described_class.new(:resource => resource) }
+
+    before do
+      resource[:ensure] = :file
+    end
+
+    with_digest_algorithms do
+      before(:each) do
+        resource[:checksum] = digest_algorithm
+      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"
+        expect(content).to be_safe_insync("whatever")
+      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
+
+      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"
+
+        expect(content).not_to be_safe_insync(:absent)
+      end
+
+      describe "and the file exists" do
+        before do
+          resource.stubs(:stat).returns mock("stat")
+          content.should = "some content"
+        end
+
+        it "should return false if the current contents are different from the desired content" do
+          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
+          expect(content).to be_safe_insync("{#{digest_algorithm}}" + digest("some content"))
+        end
+
+        it "should include the diff module" do
+          expect(content.respond_to?("diff")).to eq(false)
+        end
+
+        [true, false].product([true, false]).each do |cfg, param|
+          describe "and Puppet[:show_diff] is #{cfg} and show_diff => #{param}" do
+            before do
+              Puppet[:show_diff] = cfg
+              resource.stubs(:show_diff?).returns param
+              resource[:loglevel] = "debug"
+            end
+
+            if cfg and param
+              it "should display a diff" do
+                content.expects(:diff).returns("my diff").once
+                content.expects(:debug).with("\nmy diff").once
+                expect(content).not_to be_safe_insync("other content")
+              end
+            else
+              it "should not display a diff" do
+                content.expects(:diff).never
+                expect(content).not_to be_safe_insync("other content")
+              end
+            end
+          end
+        end
+      end
+    end
+
+    let(:saved_time) { Time.now }
+    [:ctime, :mtime].each do |time_stat|
+      [["older", -1, false], ["same", 0, true], ["newer", 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}}#{saved_time+target_time}")
+            else
+              expect(content).not_to be_safe_insync("{#{time_stat}}#{saved_time+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
+      end
+
+      it "should be insync if the file exists and the content is different" do
+        resource.stubs(:stat).returns mock('stat')
+
+        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')
+
+        expect(content).to be_safe_insync("something")
+      end
+
+      it "should not be insync if the file does not exist" do
+        content.should = "foo"
+        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
+    let(:content) { described_class.new(:resource => resource) }
+
+    before do
+      resource.stubs(:[]).with(:path).returns "/boo"
+      resource.stubs(:stat).returns "eh"
+    end
+
+    it "should use the file's :write method to write the content" do
+      resource.expects(:write).with(content)
+
+      content.sync
+    end
+
+    it "should return :file_changed if the file already existed" do
+      resource.expects(:stat).returns "something"
+      resource.stubs(:write)
+      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)
+      expect(content.sync).to eq(:file_created)
+    end
+  end
+
+  describe "when writing" do
+    let(:content) { described_class.new(:resource => resource) }
+
+    let(:fh) { File.open(filename, 'wb') }
+
+    it "should attempt to read from the filebucket if no actual content nor source exists" do
+      content.should = "{md5}foo"
+      content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
+      content.write(fh)
+      fh.close
+    end
+
+    describe "from actual content" do
+      before(:each) do
+        content.stubs(:actual_content).returns("this is content")
+      end
+
+      it "should write to the given file handle" do
+        fh = mock 'filehandle'
+        fh.expects(:print).with("this is content")
+        content.write(fh)
+      end
+
+      it "should return the current checksum value" do
+        resource.parameter(:checksum).expects(:sum_stream).returns "checksum"
+        expect(content.write(fh)).to eq("checksum")
+      end
+    end
+
+    describe "from a file bucket" do
+      it "should fail if a file bucket cannot be retrieved" do
+        content.should = "{md5}foo"
+        content.resource.expects(:bucket).returns nil
+        expect { content.write(fh) }.to raise_error(Puppet::Error)
+      end
+
+      it "should fail if the file bucket cannot find any content" do
+        content.should = "{md5}foo"
+        bucket = stub 'bucket'
+        content.resource.expects(:bucket).returns bucket
+        bucket.expects(:getfile).with("foo").raises "foobar"
+        expect { content.write(fh) }.to raise_error(Puppet::Error)
+      end
+
+      it "should write the returned content to the file" do
+        content.should = "{md5}foo"
+        bucket = stub 'bucket'
+        content.resource.expects(:bucket).returns bucket
+        bucket.expects(:getfile).with("foo").returns "mycontent"
+
+        fh = mock 'filehandle'
+        fh.expects(:print).with("mycontent")
+        content.write(fh)
+      end
+    end
+  end
+end