puppet 0.24.9 → 0.25.0

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

@@ -2,29 +2,267 @@
 
 Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
 
-property = Puppet::Type.type(:file).attrclass(:content)
-
-describe property do
+content = Puppet::Type.type(:file).attrclass(:content)
+describe content do
     before do
-        @resource = stub 'resource', :line => "foo", :file => "bar", :replace? => true
-        @resource.stubs(:[]).returns "foo"
-        @resource.stubs(:[]).with(:path).returns "/my/file"
-        @content = property.new :resource => @resource
+        # Wow that's a messy interface to the resource.
+        @resource = stub 'resource', :[] => nil, :[]= => nil, :property => nil, :newattr => nil, :parameter => nil
     end
 
-    it "should not include current contents when producing a change log" do
-        @content.change_to_s("current_content", "desired").should_not be_include("current_content")
+    it "should be a subclass of Property" do
+        content.superclass.must == Puppet::Property
     end
 
-    it "should not include desired contents when producing a change log" do
-        @content.change_to_s("current", "desired_content").should_not be_include("desired_content")
+    describe "when determining the checksum type" do
+        it "should use the type specified in the source checksum if a source is set" do
+            source = mock 'source'
+            source.expects(:checksum).returns "{litemd5}eh"
+
+            @resource.expects(:parameter).with(:source).returns source
+
+            @content = content.new(:resource => @resource)
+            @content.checksum_type.should == :litemd5
+        end
+
+        it "should use the type specified by the checksum parameter if no source is set" do
+            checksum = mock 'checksum'
+            checksum.expects(:checktype).returns :litemd5
+
+            @resource.expects(:parameter).with(:source).returns nil
+            @resource.expects(:parameter).with(:checksum).returns checksum
+
+            @content = content.new(:resource => @resource)
+            @content.checksum_type.should == :litemd5
+        end
+
+        it "should only return the checksum type from the checksum parameter if the parameter returns a whole checksum" do
+            checksum = mock 'checksum'
+            checksum.expects(:checktype).returns "{md5}something"
+
+            @resource.expects(:parameter).with(:source).returns nil
+            @resource.expects(:parameter).with(:checksum).returns checksum
+
+            @content = content.new(:resource => @resource)
+            @content.checksum_type.should == :md5
+        end
+
+        it "should use md5 if neither a source nor a checksum parameter is available" do
+            @content = content.new(:resource => @resource)
+            @content.checksum_type.should == :md5
+        end
     end
 
-    it "should not include the content when converting current content to a string" do
-        @content.is_to_s("my_content").should_not be_include("my_content")
+    describe "when determining the actual content to write" do
+        it "should use the set content if available" do
+            @content = content.new(:resource => @resource)
+            @content.should = "ehness"
+            @content.actual_content.should == "ehness"
+        end
+
+        it "should use the content from the source if the source is set" do
+            source = mock 'source'
+            source.expects(:content).returns "scont"
+
+            @resource.expects(:parameter).with(:source).returns source
+
+            @content = content.new(:resource => @resource)
+            @content.actual_content.should == "scont"
+        end
+
+        it "should return nil if no source is available and no content is set" do
+            @content = content.new(:resource => @resource)
+            @content.actual_content.should be_nil
+        end
     end
 
-    it "should not include the content when converting desired content to a string" do
-        @content.should_to_s("my_content").should_not be_include("my_content")
+    describe "when setting the desired content" do
+        it "should make the actual content available via an attribute" do
+            @content = content.new(:resource => @resource)
+            @content.stubs(:checksum_type).returns "md5"
+            @content.should = "this is some content"
+
+            @content.actual_content.should == "this is some content"
+        end
+
+        it "should store the checksum as the desired content" do
+            @content = content.new(:resource => @resource)
+            digest = Digest::MD5.hexdigest("this is some content")
+
+            @content.stubs(:checksum_type).returns "md5"
+            @content.should = "this is some content"
+
+            @content.should.must == "{md5}#{digest}"
+        end
+
+        it "should not checksum 'absent'" do
+            @content = content.new(:resource => @resource)
+            @content.should = :absent
+
+            @content.should.must == :absent
+        end
+    end
+
+    describe "when retrieving the current content" do
+        it "should return :absent if the file does not exist" do
+            @content = content.new(:resource => @resource)
+            @resource.expects(:stat).returns nil
+
+            @content.retrieve.should == :absent
+        end
+
+        it "should not manage content on directories" do
+            @content = content.new(:resource => @resource)
+
+            stat = mock 'stat', :ftype => "directory"
+            @resource.expects(:stat).returns stat
+
+            @content.retrieve.should be_nil
+        end
+
+        it "should always return the checksum as a string" do
+            @content = content.new(:resource => @resource)
+            @content.stubs(:checksum_type).returns "mtime"
+
+            stat = mock 'stat', :ftype => "file"
+            @resource.expects(:stat).returns stat
+
+            @resource.expects(:[]).with(:path).returns "/my/file"
+
+            time = Time.now
+            @content.expects(:mtime_file).with("/my/file").returns time
+
+            @content.retrieve.should == "{mtime}%s" % time
+        end
+
+        it "should return the checksum of the file if it exists and is a normal file" do
+            @content = content.new(:resource => @resource)
+            @content.stubs(:checksum_type).returns "md5"
+
+            stat = mock 'stat', :ftype => "file"
+            @resource.expects(:stat).returns stat
+
+            @resource.expects(:[]).with(:path).returns "/my/file"
+
+            @content.expects(:md5_file).with("/my/file").returns "mysum"
+
+            @content.retrieve.should == "{md5}mysum"
+        end
+    end
+
+    describe "when testing whether the content is in sync" do
+        before do
+            @resource.stubs(:[]).with(:ensure).returns :file
+            @resource.stubs(:replace?).returns true
+            @resource.stubs(:should_be_file?).returns true
+            @content = content.new(:resource => @resource)
+            @content.stubs(:checksum_type).returns "md5"
+        end
+
+        it "should return true if the resource shouldn't be a regular file" do
+            @resource.expects(:should_be_file?).returns false
+            @content.must be_insync("whatever")
+        end
+
+        it "should return false if the current content is :absent" do
+            @content.should_not be_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_not be_insync(:absent)
+        end
+
+        describe "and the file exists" do
+            before do
+                @resource.stubs(:stat).returns mock("stat")
+            end
+
+            it "should return false if the current contents are different from the desired content" do
+                @content.should = "some content"
+                @content.should_not be_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.should = "some content"
+                @content.must be_insync("{md5}" + Digest::MD5.hexdigest("some content"))
+            end
+
+            describe "and the content is specified via a remote source" do
+                before do
+                    @metadata = stub 'metadata'
+                    @source = stub 'source', :metadata => @metadata
+                    @resource.stubs(:parameter).with(:source).returns @source
+                end
+
+                it "should use checksums to compare remote content, rather than downloading the content" do
+                    @source.stubs(:checksum).returns "{md5}whatever"
+
+                    @content.insync?("{md5}eh")
+                end
+
+                it "should return false if the current content is different from the remote content" do
+                    @source.stubs(:checksum).returns "{md5}whatever"
+
+                    @content.should_not be_insync("some content")
+                end
+
+                it "should return true if the current content is the same as the remote content" do
+                    @source.stubs(:checksum).returns("{md5}something")
+
+                    @content.must be_insync("{md5}something")
+                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')
+
+                @content.must be_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_insync("something")
+            end
+
+            it "should not be insync if the file does not exist" do
+                @content.should_not be_insync(:absent)
+            end
+        end
+    end
+
+    describe "when changing the content" do
+        before do
+            @content = content.new(:resource => @resource)
+            @content.should = "some content"
+
+            @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("some content", :content)
+
+            @content.sync
+        end
+
+        it "should return :file_changed if the file already existed" do
+            @resource.expects(:stat).returns "something"
+            @resource.stubs(:write)
+            @content.sync.should == :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
+        end
     end
 end

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

@@ -6,16 +6,79 @@ property = Puppet::Type.type(:file).attrclass(:ensure)
 
 describe property do
     before do
-        @resource = stub 'resource', :line => "foo", :file => "bar", :replace? => true
+        # Wow that's a messy interface to the resource.
+        @resource = stub 'resource', :[] => nil, :[]= => nil, :property => nil, :newattr => nil, :parameter => nil, :replace? => true
         @resource.stubs(:[]).returns "foo"
         @resource.stubs(:[]).with(:path).returns "/my/file"
         @ensure = property.new :resource => @resource
     end
 
-    describe "when testing whether in sync" do
+    it "should be a subclass of Ensure" do
+        property.superclass.must == Puppet::Property::Ensure
+    end
+
+    describe "when retrieving the current state" do
+        it "should return :absent if the file does not exist" do
+            @ensure = property.new(:resource => @resource)
+            @resource.expects(:stat).returns nil
+
+            @ensure.retrieve.should == :absent
+        end
+
+        it "should return the current file type if the file exists" do
+            @ensure = property.new(:resource => @resource)
+            stat = mock 'stat', :ftype => "directory"
+            @resource.expects(:stat).returns stat
+
+            @ensure.retrieve.should == :directory
+        end
+    end
+
+    describe "when testing whether :ensure is in sync" do
+        before do
+            @ensure = property.new(:resource => @resource)
+            @stat = stub 'stat', :ftype => "file"
+        end
+
         it "should always be in sync if replace is 'false' unless the file is missing" do
             @resource.expects(:replace?).returns false
             @ensure.insync?(:link).should be_true
         end
+
+        it "should be in sync if :ensure is set to :absent and the file does not exist" do
+            @ensure.should = :absent
+
+            @ensure.must be_insync(:absent)
+        end
+
+        it "should not be in sync if :ensure is set to :absent and the file exists" do
+            @ensure.should = :absent
+
+            @ensure.should_not be_insync(:file)
+        end
+
+        it "should be in sync if a normal file exists and :ensure is set to :present" do
+            @ensure.should = :present
+
+            @ensure.must be_insync(:file)
+        end
+
+        it "should be in sync if a directory exists and :ensure is set to :present" do
+            @ensure.should = :present
+
+            @ensure.must be_insync(:directory)
+        end
+
+        it "should be in sync if a symlink exists and :ensure is set to :present" do
+            @ensure.should = :present
+
+            @ensure.must be_insync(:link)
+        end
+
+        it "should not be in sync if :ensure is set to :file and a directory exists" do
+            @ensure.should = :file
+
+            @ensure.should_not be_insync(:directory)
+        end
     end
 end

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

@@ -70,6 +70,11 @@ describe property do
 
             @group.must be_insync(10)
         end
+        
+        it "should not validate that groups exist when a group is specified as an integer" do
+            @group.expects(:gid).never
+            @group.validgroup?(10)
+        end
 
         it "should fail if it cannot convert a group name to an integer" do
             @group.expects(:gid).with("foo").returns nil

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

@@ -83,6 +83,11 @@ describe property do
 
             @owner.must be_insync(10)
         end
+        
+        it "should not validate that users exist when a user is specified as an integer" do
+            @owner.expects(:uid).never
+            @owner.validuser?(10)
+        end
 
         it "should fail if it cannot convert an owner name to an integer" do
             @owner.expects(:uid).with("foo").returns nil

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

@@ -29,10 +29,10 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
             @resource.expects(:stat).returns stat
             @sel.expects(:get_selinux_current_context).with("/my/file").returns "user_u:role_r:type_t:s0"
             expectedresult = case param
-                when :seluser then "user_u"
-                when :selrole then "role_r"
-                when :seltype then "type_t"
-                when :selrange then "s0"
+                when :seluser; "user_u"
+                when :selrole; "role_r"
+                when :seltype; "type_t"
+                when :selrange; "s0"
             end
             @sel.retrieve.should == expectedresult
         end
@@ -42,10 +42,10 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
             @resource.expects(:stat).returns stat
             @sel.expects(:get_selinux_current_context).with("/my/file").returns "user_u:role_r:type_t"
             expectedresult = case param
-                when :seluser then "user_u"
-                when :selrole then "role_r"
-                when :seltype then "type_t"
-                when :selrange then nil
+                when :seluser; "user_u"
+                when :selrole; "role_r"
+                when :seltype; "type_t"
+                when :selrange; nil
             end
             @sel.retrieve.should == expectedresult
         end
@@ -59,10 +59,10 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
             @sel.stubs(:debug)
             @sel.expects(:get_selinux_default_context).with("/my/file").returns "user_u:role_r:type_t:s0"
             expectedresult = case param
-                when :seluser then "user_u"
-                when :selrole then "role_r"
-                when :seltype then "type_t"
-                when :selrange then "s0"
+                when :seluser; "user_u"
+                when :selrole; "role_r"
+                when :seltype; "type_t"
+                when :selrange; "s0"
             end
             @sel.default.must == expectedresult
         end
@@ -79,10 +79,6 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
             @sel.expects(:selinux_support?).returns false
             @sel.insync?("oldcontext").should == true
         end
-
-        after do
-            Puppet::Type.type(:file).clear
-        end
     end
 end
 

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

@@ -0,0 +1,264 @@
+#!/usr/bin/env ruby
+
+Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f) : Dir.chdir("..") { s.call(f) } }).call("spec/spec_helper.rb") }
+
+source = Puppet::Type.type(:file).attrclass(:source)
+describe Puppet::Type.type(:file).attrclass(:source) do
+    before do
+        # Wow that's a messy interface to the resource.
+        @resource = stub 'resource', :[]= => nil, :property => nil, :catalog => stub("catalog", :dependent_data_expired? => false)
+    end
+
+    it "should be a subclass of Parameter" do
+        source.superclass.must == Puppet::Parameter
+    end
+
+    describe "when initializing" do
+        it "should fail if the set values are not URLs" do
+            s = source.new(:resource => @resource)
+            URI.expects(:parse).with('foo').raises RuntimeError
+
+            lambda { s.value = %w{foo} }.must raise_error(Puppet::Error)
+        end
+
+        it "should fail if the URI is not a local file, file URI, or puppet URI" do
+            s = source.new(:resource => @resource)
+
+            lambda { s.value = %w{http://foo/bar} }.must raise_error(Puppet::Error)
+        end
+    end
+
+    it "should have a method for retrieving its metadata" do
+        source.new(:resource => @resource).must respond_to(:metadata)
+    end
+
+    it "should have a method for setting its metadata" do
+        source.new(:resource => @resource).must respond_to(:metadata=)
+    end
+
+    describe "when returning the metadata" do
+        before do
+            @metadata = stub 'metadata', :source= => nil
+        end
+
+        it "should return already-available metadata" do
+            @source = source.new(:resource => @resource)
+            @source.metadata = "foo"
+            @source.metadata.should == "foo"
+        end
+
+        it "should return nil if no @should value is set and no metadata is available" do
+            @source = source.new(:resource => @resource)
+            @source.metadata.should be_nil
+        end
+
+        it "should collect its metadata using the Metadata class if it is not already set" do
+            @source = source.new(:resource => @resource, :value => "/foo/bar")
+            Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns @metadata
+            @source.metadata
+        end
+
+        it "should use the metadata from the first found source" do
+            metadata = stub 'metadata', :source= => nil
+            @source = source.new(:resource => @resource, :value => ["/foo/bar", "/fee/booz"])
+            Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
+            Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
+            @source.metadata.should equal(metadata)
+        end
+
+        it "should store the found source as the metadata's source" do
+            metadata = mock 'metadata'
+            @source = source.new(:resource => @resource, :value => "/foo/bar")
+            Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns metadata
+
+            metadata.expects(:source=).with("/foo/bar")
+            @source.metadata
+        end
+
+        it "should fail intelligently if an exception is encountered while querying for metadata" do
+            @source = source.new(:resource => @resource, :value => "/foo/bar")
+            Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").raises RuntimeError
+
+            @source.expects(:fail).raises ArgumentError
+            lambda { @source.metadata }.should raise_error(ArgumentError)
+        end
+
+        it "should fail if no specified sources can be found" do
+            @source = source.new(:resource => @resource, :value => "/foo/bar")
+            Puppet::FileServing::Metadata.expects(:find).with("/foo/bar").returns nil
+
+            @source.expects(:fail).raises RuntimeError
+
+            lambda { @source.metadata }.should raise_error(RuntimeError)
+        end
+
+        it "should expire the metadata appropriately" do
+            expirer = stub 'expired', :dependent_data_expired? => true
+
+            metadata = stub 'metadata', :source= => nil
+            Puppet::FileServing::Metadata.expects(:find).with("/fee/booz").returns metadata
+
+            @source = source.new(:resource => @resource, :value => ["/fee/booz"])
+            @source.metadata = "foo"
+
+            @source.stubs(:expirer).returns expirer
+
+            @source.metadata.should_not == "foo"
+        end
+    end
+
+    it "should have a method for setting the desired values on the resource" do
+        source.new(:resource => @resource).must respond_to(:copy_source_values)
+    end
+
+    describe "when copying the source values" do
+        before do
+            @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf"
+
+            @source = source.new(:resource => @resource)
+            @source.metadata = @metadata
+
+            @resource.stubs(:deleting?).returns false
+        end
+
+        it "should fail if there is no metadata" do
+            @source.metadata = nil
+            @source.expects(:devfail).raises ArgumentError
+            lambda { @source.copy_source_values }.should raise_error(ArgumentError)
+        end
+
+        it "should set :ensure to the file type" do
+            @resource.stubs(:[])
+            @resource.stubs(:[]=)
+            @metadata.stubs(:ftype).returns "foobar"
+
+            @resource.expects(:[]=).with(:ensure, "foobar")
+            @source.copy_source_values
+        end
+
+        it "should not set 'ensure' if it is already set to 'absent'" do
+            @resource.stubs(:[])
+            @resource.stubs(:[]=)
+            @metadata.stubs(:ftype).returns "foobar"
+
+            @resource.expects(:[]).with(:ensure).returns :absent
+            @resource.expects(:[]=).with(:ensure, "foobar").never
+            @source.copy_source_values
+        end
+
+        describe "and the source is a file" do
+            before do
+                @metadata.stubs(:ftype).returns "file"
+            end
+
+            it "should copy the metadata's owner, group, and mode to the resource if they are not set on the resource" do
+                @resource.stubs(:[]).returns nil
+
+                Puppet::Util::SUIDManager.expects(:uid).returns 0
+
+                @resource.expects(:[]=).with(:owner, 100)
+                @resource.expects(:[]=).with(:group, 200)
+                @resource.expects(:[]=).with(:mode, 123)
+                @resource.expects(:[]=).with(:checksum, "{md5}asdfasdf")
+
+                @source.copy_source_values
+            end
+
+            it "should copy the metadata's owner, group, and mode to the resource if they are set to :absent on the resource" do
+                @resource.stubs(:[]).returns :absent
+
+                Puppet::Util::SUIDManager.expects(:uid).returns 0
+
+                @resource.expects(:[]=).with(:owner, 100)
+                @resource.expects(:[]=).with(:group, 200)
+                @resource.expects(:[]=).with(:mode, 123)
+                @resource.expects(:[]=).with(:checksum, "{md5}asdfasdf")
+
+                @source.copy_source_values
+            end
+
+            it "should not copy the metadata's owner to the resource if it is already set" do
+                @resource.stubs(:[]).returns "value"
+                @resource.expects(:[]).returns "value"
+
+                @resource.expects(:[]=).never
+
+                @source.copy_source_values
+            end
+
+            describe "and puppet is not running as root" do
+                it "should not try to set the owner" do
+                    @resource.stubs(:[]).returns nil
+                    @resource.stubs(:[]=)
+
+                    @resource.expects(:[]=).with(:owner, 100).never
+
+                    Puppet::Util::SUIDManager.expects(:uid).returns 100
+
+                    @source.copy_source_values
+                end
+            end
+        end
+
+        describe "and the source is a link" do
+            it "should set the target to the link destination" do
+                @metadata.stubs(:ftype).returns "link"
+                @resource.stubs(:[])
+                @resource.stubs(:[]=)
+
+                @metadata.expects(:destination).returns "/path/to/symlink"
+
+                @resource.expects(:[]=).with(:target, "/path/to/symlink")
+                @source.copy_source_values
+            end
+        end
+    end
+
+    it "should have a method for returning the content" do
+        source.new(:resource => @resource).must respond_to(:content)
+    end
+
+    describe "when looking up the content" do
+        before do
+            @source = source.new(:resource => @resource)
+            @metadata = stub 'metadata', :source => "/my/source"
+            @source.stubs(:metadata).returns @metadata
+
+            @content = stub 'content', :content => "foobar"
+        end
+
+        it "should fail if the metadata does not have a source set" do
+            @metadata.stubs(:source).returns nil
+            lambda { @source.content }.should raise_error(Puppet::DevError)
+        end
+
+        it "should look the content up from the Content class using the metadata source if no content is set" do
+            Puppet::FileServing::Content.expects(:find).with("/my/source").returns @content
+            @source.content.should == "foobar"
+        end
+
+        it "should return previously found content" do
+            Puppet::FileServing::Content.expects(:find).with("/my/source").returns @content
+            @source.content.should == "foobar"
+            @source.content.should == "foobar"
+        end
+
+        it "should fail if no content can be retrieved" do
+            Puppet::FileServing::Content.expects(:find).with("/my/source").returns nil
+            @source.expects(:fail).raises RuntimeError
+            lambda { @source.content }.should raise_error(RuntimeError)
+        end
+
+        it "should expire the content appropriately" do
+            expirer = stub 'expired', :dependent_data_expired? => true
+
+            content2 = stub 'content', :content => "secondrun"
+            Puppet::FileServing::Content.expects(:find).with("/my/source").times(2).returns(@content).then.returns(content2)
+            @source.content.should == "foobar"
+
+            @source.stubs(:expirer).returns expirer
+
+            @source.content.should == "secondrun"
+        end
+    end
+end