puppet 0.25.5 → 2.6.0

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

@@ -1,28 +0,0 @@
-#!/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") }
-
-checksum = Puppet::Type.type(:file).attrclass(:checksum)
-describe checksum do
-    before do
-        # Wow that's a messy interface to the resource.
-        @resource = stub 'resource', :[] => nil, :[]= => nil, :property => nil, :newattr => nil, :parameter => nil
-    end
-
-    it "should be a subclass of Property" do
-        checksum.superclass.must == Puppet::Property
-    end
-
-    it "should have default checksum of :md5" do
-        @checksum = checksum.new(:resource => @resource)
-        @checksum.checktype.should == :md5
-    end
-
-    [:none, nil, ""].each do |ck|
-        it "should use a none checksum for #{ck.inspect}" do
-            @checksum = checksum.new(:resource => @resource)
-            @checksum.should = "none"
-            @checksum.checktype.should == :none
-        end
-    end
-end

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

@@ -1,297 +0,0 @@
-#!/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") }
-
-content = Puppet::Type.type(:file).attrclass(:content)
-describe content do
-    before do
-        # Wow that's a messy interface to the resource.
-        @resource = stub 'resource', :[] => nil, :[]= => nil, :property => nil, :newattr => nil, :parameter => nil
-    end
-
-    it "should be a subclass of Property" do
-        content.superclass.must == Puppet::Property
-    end
-
-    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
-
-    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
-
-    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 not manage content on links" do
-            @content = content.new(:resource => @resource)
-
-            stat = mock 'stat', :ftype => "link"
-            @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 Puppet[:show_diff] is set" do
-                before do
-                    Puppet[:show_diff] = true
-                end
-
-                it "should display a diff if the current contents are different from the desired content" do 
-                    @content.should = "some content"
-                    @content.expects(:string_file_diff).once
-
-                    @content.insync?("other content")
-                end
-
-                it "should not display a diff if the sum for the current contents is the same as the sum for the desired content" do 
-                    @content.should = "some content"
-                    @content.expects(:string_file_diff).never
-
-                    @content.insync?("{md5}" + Digest::MD5.hexdigest("some content"))
-                end
-            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

@@ -1,84 +0,0 @@
-#!/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") }
-
-property = Puppet::Type.type(:file).attrclass(:ensure)
-
-describe property do
-    before do
-        # 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
-
-    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

@@ -1,123 +0,0 @@
-#!/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") }
-
-property = Puppet::Type.type(:file).attrclass(:group)
-
-describe property do
-    before do
-        @resource = stub 'resource', :line => "foo", :file => "bar"
-        @resource.stubs(:[]).returns "foo"
-        @resource.stubs(:[]).with(:path).returns "/my/file"
-        @group = property.new :resource => @resource
-    end
-
-    it "should have a method for testing whether a group is valid" do
-        @group.must respond_to(:validgroup?)
-    end
-
-    it "should return the found gid if a group is valid" do
-        @group.expects(:gid).with("foo").returns 500
-        @group.validgroup?("foo").should == 500
-    end
-
-    it "should return false if a group is not valid" do
-        @group.expects(:gid).with("foo").returns nil
-        @group.validgroup?("foo").should be_false
-    end
-
-    describe "when retrieving the current value" do
-        it "should return :absent if the file cannot stat" do
-            @resource.expects(:stat).returns nil
-
-            @group.retrieve.should == :absent
-        end
-
-        it "should get the gid from the stat instance from the file" do
-            stat = stub 'stat', :ftype => "foo"
-            @resource.expects(:stat).returns stat
-            stat.expects(:gid).returns 500
-
-            @group.retrieve.should == 500
-        end
-
-        it "should warn and return :silly if the found value is higher than the maximum uid value" do
-            Puppet.settings.expects(:value).with(:maximum_uid).returns 500
-
-            stat = stub 'stat', :ftype => "foo"
-            @resource.expects(:stat).returns stat
-            stat.expects(:gid).returns 1000
-
-            @group.expects(:warning)
-            @group.retrieve.should == :silly
-        end
-    end
-
-    describe "when determining if the file is in sync" do
-        it "should directly compare the group values if the desired group is an integer" do
-            @group.should = [10]
-            @group.must be_insync(10)
-        end
-
-        it "should treat numeric strings as integers" do
-            @group.should = ["10"]
-            @group.must be_insync(10)
-        end
-
-        it "should convert the group name to an integer if the desired group is a string" do
-            @group.expects(:gid).with("foo").returns 10
-            @group.should = %w{foo}
-
-            @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
-            @group.should = %w{foo}
-
-            lambda { @group.insync?(10) }.should raise_error(Puppet::Error)
-        end
-
-        it "should return false if the groups are not equal" do
-            @group.should = [10]
-            @group.should_not be_insync(20)
-        end
-    end
-
-    describe "when changing the group" do
-        before do
-            @group.should = %w{one}
-            @group.stubs(:gid).returns 500
-        end
-
-        it "should chown the file if :links is set to :follow" do
-            @resource.expects(:[]).with(:links).returns :follow
-            File.expects(:chown)
-
-            @group.sync
-        end
-
-        it "should lchown the file if :links is set to :manage" do
-            @resource.expects(:[]).with(:links).returns :manage
-            File.expects(:lchown)
-
-            @group.sync
-        end
-
-        it "should use the first valid group in its 'should' list" do
-            @group.should = %w{one two three}
-            @group.expects(:validgroup?).with("one").returns nil
-            @group.expects(:validgroup?).with("two").returns 500
-            @group.expects(:validgroup?).with("three").never
-
-            File.expects(:chown).with(nil, 500, "/my/file")
-
-            @group.sync
-        end
-    end
-end