puppet 0.25.5 → 2.6.0

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

@@ -0,0 +1,84 @@
+#!/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_spec.rb

@@ -0,0 +1,123 @@
+#!/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

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

@@ -0,0 +1,150 @@
+#!/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(:owner)
+
+describe property do
+  before do
+    # FIXME: many of these tests exercise the provider rather than `owner`
+    # and should be moved into provider tests. ~JW
+    @provider = Puppet::Type.type(:file).provider(:posix).new
+    @provider.stubs(:uid).with("one").returns(1)
+
+    @resource = stub 'resource', :line => "foo", :file => "bar"
+    @resource.stubs(:[]).returns "foo"
+    @resource.stubs(:[]).with(:path).returns "/my/file"
+    @resource.stubs(:provider).returns @provider
+
+    @owner = property.new :resource => @resource
+  end
+
+  it "should have a method for testing whether an owner is valid" do
+    @provider.must respond_to(:validuser?)
+  end
+
+  it "should return the found uid if an owner is valid" do
+    @provider.expects(:uid).with("foo").returns 500
+    @provider.validuser?("foo").should == 500
+  end
+
+  it "should return false if an owner is not valid" do
+    @provider.expects(:uid).with("foo").returns nil
+    @provider.validuser?("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
+
+      @owner.retrieve.should == :absent
+    end
+
+    it "should get the uid from the stat instance from the file" do
+      stat = stub 'stat', :ftype => "foo"
+      @resource.expects(:stat).returns stat
+      stat.expects(:uid).returns 500
+
+      @owner.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(:uid).returns 1000
+
+      @provider.expects(:warning)
+      @owner.retrieve.should == :silly
+    end
+  end
+
+  describe "when determining if the file is in sync" do
+    describe "and not running as root" do
+      it "should warn once and return true" do
+        Puppet.features.expects(:root?).returns false
+
+        @provider.expects(:warnonce)
+
+        @owner.should = [10]
+        @owner.must be_insync(20)
+      end
+    end
+
+    before do
+      Puppet.features.stubs(:root?).returns true
+    end
+
+    it "should be in sync if 'should' is not provided" do
+      @owner.must be_insync(10)
+    end
+
+    it "should directly compare the owner values if the desired owner is an integer" do
+      @owner.should = [10]
+      @owner.must be_insync(10)
+    end
+
+    it "should treat numeric strings as integers" do
+      @owner.should = ["10"]
+      @owner.must be_insync(10)
+    end
+
+    it "should convert the owner name to an integer if the desired owner is a string" do
+      @provider.expects(:uid).with("foo").returns 10
+      @owner.should = %w{foo}
+
+      @owner.must be_insync(10)
+    end
+
+    it "should not validate that users exist when a user is specified as an integer" do
+      @provider.expects(:uid).never
+      @provider.validuser?(10)
+    end
+
+    it "should fail if it cannot convert an owner name to an integer" do
+      @provider.expects(:uid).with("foo").returns nil
+      @owner.should = %w{foo}
+
+      lambda { @owner.insync?(10) }.should raise_error(Puppet::Error)
+    end
+
+    it "should return false if the owners are not equal" do
+      @owner.should = [10]
+      @owner.should_not be_insync(20)
+    end
+  end
+
+  describe "when changing the owner" do
+    before do
+      @owner.should = %w{one}
+      @owner.stubs(:path).returns "path"
+      @owner.stubs(:uid).returns 500
+    end
+
+    it "should chown the file if :links is set to :follow" do
+      @resource.expects(:[]).with(:links).returns :follow
+      File.expects(:chown)
+
+      @owner.sync
+    end
+
+    it "should lchown the file if :links is set to :manage" do
+      @resource.expects(:[]).with(:links).returns :manage
+      File.expects(:lchown)
+
+      @owner.sync
+    end
+
+    it "should use the first valid owner in its 'should' list" do
+      @owner.should = %w{one two three}
+      @provider.expects(:validuser?).with("one").returns nil
+      @provider.expects(:validuser?).with("two").returns 500
+      @provider.expects(:validuser?).with("three").never
+
+      File.expects(:chown).with(500, nil, "/my/file")
+
+      @owner.sync
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+#!/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") }
+
+
+[:seluser, :selrole, :seltype, :selrange].each do |param|
+  property = Puppet::Type.type(:file).attrclass(param)
+  describe property do
+    before do
+      @resource = Puppet::Type.type(:file).new :path => "/my/file"
+      @sel = property.new :resource => @resource
+    end
+
+    it "retrieve on #{param} should return :absent if the file isn't statable" do
+      @resource.expects(:stat).returns nil
+      @sel.retrieve.should == :absent
+    end
+
+    it "should retrieve nil for #{param} if there is no SELinux support" do
+      stat = stub 'stat', :ftype => "foo"
+      @resource.expects(:stat).returns stat
+      @sel.expects(:get_selinux_current_context).with("/my/file").returns nil
+      @sel.retrieve.should be_nil
+    end
+
+    it "should retrieve #{param} if a SELinux context is found with a range" do
+      stat = stub 'stat', :ftype => "foo"
+      @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; "user_u"
+        when :selrole; "role_r"
+        when :seltype; "type_t"
+        when :selrange; "s0"
+      end
+      @sel.retrieve.should == expectedresult
+    end
+
+    it "should retrieve #{param} if a SELinux context is found without a range" do
+      stat = stub 'stat', :ftype => "foo"
+      @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; "user_u"
+        when :selrole; "role_r"
+        when :seltype; "type_t"
+        when :selrange; nil
+      end
+      @sel.retrieve.should == expectedresult
+    end
+
+    it "should handle no default gracefully" do
+      @sel.expects(:get_selinux_default_context).with("/my/file").returns nil
+      @sel.default.must be_nil
+    end
+
+    it "should be able to detect matchpathcon defaults" do
+      @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; "user_u"
+        when :selrole; "role_r"
+        when :seltype; "type_t"
+        when :selrange; "s0"
+      end
+      @sel.default.must == expectedresult
+    end
+
+    it "should be able to set a new context" do
+      stat = stub 'stat', :ftype => "foo"
+      @sel.should = %w{newone}
+      @sel.expects(:set_selinux_context).with("/my/file", ["newone"], param)
+      @sel.sync
+    end
+
+    it "should do nothing for insync? if no SELinux support" do
+      @sel.should = %{newcontext}
+      @sel.expects(:selinux_support?).returns false
+      @sel.insync?("oldcontext").should == true
+    end
+  end
+end
+

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

@@ -0,0 +1,272 @@
+#!/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
+
+      @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
+
+      @source = source.new(:resource => @resource)
+      @metadata = stub 'metadata', :owner => 100, :group => 200, :mode => 123, :checksum => "{md5}asdfasdf", :ftype => "file"
+      @source.stubs(:metadata).returns @metadata
+    end
+
+    it "should fail if there is no metadata" do
+      @source.stubs(:metadata).returns 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
+      @metadata.stubs(:ftype).returns "file"
+
+      @source.copy_source_values
+      @resource[:ensure].must == :file
+    end
+
+    it "should not set 'ensure' if it is already set to 'absent'" do
+      @metadata.stubs(:ftype).returns "file"
+
+      @resource[:ensure] = :absent
+      @source.copy_source_values
+      @resource[:ensure].must == :absent
+    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, checksum, and mode to the resource if they are not set on the resource" do
+        Puppet.features.expects(:root?).returns true
+
+        @source.copy_source_values
+
+        @resource[:owner].must == 100
+        @resource[:group].must == 200
+        @resource[:mode].must == 123
+
+        # Metadata calls it checksum, we call it content.
+        @resource[:content].must == @metadata.checksum
+      end
+
+      it "should not copy the metadata's owner to the resource if it is already set" do
+        @resource[:owner] = 1
+        @resource[:group] = 2
+        @resource[:mode] = 3
+        @resource[:content] = "foobar"
+
+        @source.copy_source_values
+
+        @resource[:owner].must == 1
+        @resource[:group].must == 2
+        @resource[:mode].must == 3
+        @resource[:content].should_not == @metadata.checksum
+      end
+
+      describe "and puppet is not running as root" do
+        it "should not try to set the owner" do
+          Puppet.features.expects(:root?).returns false
+
+          @source.copy_source_values
+          @resource[:owner].should be_nil
+        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 local? method" do
+    source.new(:resource => @resource).must be_respond_to(:local?)
+  end
+
+  context "when accessing source properties" do
+    before(:each) do
+      @source = source.new(:resource => @resource)
+      @metadata = stub_everything
+      @source.stubs(:metadata).returns(@metadata)
+    end
+
+    describe "for local sources" do
+      before(:each) do
+        @metadata.stubs(:ftype).returns "file"
+        @metadata.stubs(:source).returns("file:///path/to/source")
+      end
+
+      it "should be local" do
+        @source.must be_local
+      end
+
+      it "should be local if there is no scheme" do
+        @metadata.stubs(:source).returns("/path/to/source")
+        @source.must be_local
+      end
+
+      it "should be able to return the metadata source full path" do
+        @source.full_path.should == "/path/to/source"
+      end
+    end
+
+    describe "for remote sources" do
+      before(:each) do
+        @metadata.stubs(:ftype).returns "file"
+        @metadata.stubs(:source).returns("puppet://server:8192/path/to/source")
+      end
+
+      it "should not be local" do
+        @source.should_not be_local
+      end
+
+      it "should be able to return the metadata source full path" do
+        @source.full_path.should == "/path/to/source"
+      end
+
+      it "should be able to return the source server" do
+        @source.server.should == "server"
+      end
+
+      it "should be able to return the source port" do
+        @source.port.should == 8192
+      end
+
+      describe "which don't specify server or port" do
+        before(:each) do
+          @metadata.stubs(:source).returns("puppet:///path/to/source")
+        end
+
+        it "should return the default source server" do
+          Puppet.settings.expects(:[]).with(:server).returns("myserver")
+          @source.server.should == "myserver"
+        end
+
+        it "should return the default source port" do
+          Puppet.settings.expects(:[]).with(:masterport).returns(1234)
+          @source.port.should == 1234
+        end
+      end
+    end
+  end
+
+end