puppet 0.25.5 → 2.6.0

data/spec/unit/util/rdoc_spec.rb

@@ -0,0 +1,165 @@
+#!/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") }
+
+require 'puppet/util/rdoc'
+require 'rdoc/rdoc'
+
+describe Puppet::Util::RDoc do
+
+  describe "when generating RDoc HTML documentation" do
+    before :each do
+      @rdoc = stub_everything 'rdoc'
+      RDoc::RDoc.stubs(:new).returns(@rdoc)
+    end
+
+    it "should tell the parser to ignore import" do
+      Puppet.expects(:[]=).with(:ignoreimport, true)
+
+      Puppet::Util::RDoc.rdoc("output", [])
+    end
+
+    it "should install the Puppet HTML Generator into RDoc generators" do
+      Puppet::Util::RDoc.rdoc("output", [])
+
+      RDoc::RDoc::GENERATORS["puppet"].file_name.should == "puppet/util/rdoc/generators/puppet_generator.rb"
+    end
+
+    it "should tell RDoc to generate documentation using the Puppet generator" do
+      @rdoc.expects(:document).with { |args| args.include?("--fmt") and args.include?("puppet") }
+
+      Puppet::Util::RDoc.rdoc("output", [])
+    end
+
+    it "should tell RDoc to be quiet" do
+      @rdoc.expects(:document).with { |args| args.include?("--quiet") }
+
+      Puppet::Util::RDoc.rdoc("output", [])
+    end
+
+    it "should pass charset to RDoc" do
+      @rdoc.expects(:document).with { |args| args.include?("--charset") and args.include?("utf-8") }
+
+      Puppet::Util::RDoc.rdoc("output", [], "utf-8")
+    end
+
+    it "should tell RDoc to force updates of indices" do
+      @rdoc.expects(:document).with { |args| args.include?("--force-update") }
+
+      Puppet::Util::RDoc.rdoc("output", [])
+    end
+
+    it "should tell RDoc to use the given outputdir" do
+      @rdoc.expects(:document).with { |args| args.include?("--op") and args.include?("myoutputdir") }
+
+      Puppet::Util::RDoc.rdoc("myoutputdir", [])
+    end
+
+    it "should tell RDoc to exclude .pp files under any modules/<mod>/files section" do
+      @rdoc.expects(:document).with { |args| args.include?("--exclude") and args.include?("/modules/[^/]*/files/.*\.pp$") }
+
+      Puppet::Util::RDoc.rdoc("myoutputdir", [])
+    end
+
+    it "should give all the source directories to RDoc" do
+      @rdoc.expects(:document).with { |args| args.include?("sourcedir") }
+
+      Puppet::Util::RDoc.rdoc("output", ["sourcedir"])
+    end
+  end
+
+  describe "when running a manifest documentation" do
+    it "should tell the parser to ignore import" do
+      Puppet.expects(:[]=).with(:ignoreimport, true)
+
+      Puppet::Util::RDoc.manifestdoc([])
+    end
+
+    it "should puppet parse all given files" do
+      FileTest.stubs(:file?).returns(true)
+      Puppet::Util::RDoc.stubs(:output)
+
+      parser = stub_everything
+      Puppet::Parser::Parser.stubs(:new).returns(parser)
+
+      parser.expects(:file=).with("file")
+      parser.expects(:parse)
+
+      Puppet::Util::RDoc.manifestdoc(["file"])
+    end
+
+    it "should call output for each parsed file" do
+      FileTest.stubs(:file?).returns(true)
+
+      ast = stub_everything
+      parser = stub_everything
+      Puppet::Parser::Parser.stubs(:new).returns(parser)
+      parser.stubs(:parse).returns(ast)
+
+      Puppet::Util::RDoc.expects(:output).with("file", ast)
+
+      Puppet::Util::RDoc.manifestdoc(["file"])
+    end
+
+    describe "when outputing documentation" do
+      before :each do
+        @node = stub 'node', :file => "file", :line => 1, :doc => ""
+        @class = stub 'class', :file => "file", :line => 4, :doc => ""
+        @definition = stub 'definition', :file => "file", :line => 3, :doc => ""
+        @ast = stub 'ast', :nodes => { :node => @node }, :hostclasses => { :class => @class }, :definitions => { :definition => @definition }
+      end
+
+      it "should output doc for ast nodes" do
+        @node.expects(:doc)
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+
+      it "should output doc for ast classes" do
+        @class.expects(:doc)
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+
+      it "should output doc for ast definitions" do
+        @definition.expects(:doc)
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+
+      it "should output doc in order of increasing line number" do
+        byline = sequence('byline')
+        @node.expects(:doc).in_sequence(byline)
+        @definition.expects(:doc).in_sequence(byline)
+        @class.expects(:doc).in_sequence(byline)
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+
+      it "should not output documentation of ast object of another node" do
+        klass = stub 'otherclass', :file => "otherfile", :line => 12, :doc => ""
+        @ast.stubs(:hostclasses).returns({ :otherclass => klass })
+
+        klass.expects(:doc).never
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+
+      it "should output resource documentation if needed" do
+        Puppet.settings.stubs(:[]).with(:document_all).returns(true)
+        [@node,@definition].each do |o|
+          o.stubs(:code).returns([])
+        end
+
+        resource = stub_everything 'resource', :line => 1
+        resource.stubs(:is_a?).with(Puppet::Parser::AST::ASTArray).returns(false)
+        resource.stubs(:is_a?).with(Puppet::Parser::AST::Resource).returns(true)
+        @class.stubs(:code).returns([resource])
+
+        resource.expects(:doc)
+
+        Puppet::Util::RDoc.output("file", @ast)
+      end
+    end
+  end
+end

data/spec/unit/util/reference_serializer_spec.rb

@@ -0,0 +1,52 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'puppet/util/rails/reference_serializer'
+
+class SerializeTester
+  include Puppet::Util::ReferenceSerializer
+end
+
+describe Puppet::Util::ReferenceSerializer do
+  before do
+    @tester = SerializeTester.new
+  end
+
+  describe "when serializing" do
+    it "should yaml-dump resource references" do
+      ref = Puppet::Resource.new("file", "/foo")
+      @tester.serialize_value(ref).should =~ /^---/
+    end
+
+    it "should convert the boolean 'true' into the string 'true'" do
+      @tester.serialize_value(true).should == "true"
+    end
+
+    it "should convert the boolean 'false' into the string 'false'" do
+      @tester.serialize_value(false).should == "false"
+    end
+
+    it "should return all other values" do
+      @tester.serialize_value("foo").should == "foo"
+    end
+  end
+
+  describe "when unserializing" do
+    it "should yaml-load values that look like yaml" do
+      yaml = YAML.dump(%w{a b c})
+      @tester.unserialize_value(yaml).should == %w{a b c}
+    end
+
+    it "should convert the string 'true' into the boolean 'true'" do
+      @tester.unserialize_value("true").should == true
+    end
+
+    it "should convert the string 'false' into the boolean 'false'" do
+      @tester.unserialize_value("false").should == false
+    end
+
+    it "should return all other values" do
+      @tester.unserialize_value("foo").should == "foo"
+    end
+  end
+end

data/spec/unit/util/resource_template_spec.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/resource_template'
+
+describe Puppet::Util::ResourceTemplate do
+  describe "when initializing" do
+    it "should fail if the template does not exist" do
+      FileTest.expects(:exist?).with("/my/template").returns false
+      lambda { Puppet::Util::ResourceTemplate.new("/my/template", mock('resource')) }.should raise_error(ArgumentError)
+    end
+
+    it "should not create the ERB template" do
+      ERB.expects(:new).never
+      FileTest.expects(:exist?).with("/my/template").returns true
+      Puppet::Util::ResourceTemplate.new("/my/template", mock('resource'))
+    end
+  end
+
+  describe "when evaluating" do
+    before do
+      FileTest.stubs(:exist?).returns true
+      File.stubs(:read).returns "eh"
+
+      @template = stub 'template', :result => nil
+      ERB.stubs(:new).returns @template
+
+      @resource = mock 'resource'
+      @wrapper = Puppet::Util::ResourceTemplate.new("/my/template", @resource)
+    end
+
+    it "should set all of the resource's parameters as instance variables" do
+      @resource.expects(:to_hash).returns(:one => "uno", :two => "dos")
+      @template.expects(:result).with do |bind|
+        eval("@one", bind) == "uno" and eval("@two", bind) == "dos"
+      end
+      @wrapper.evaluate
+    end
+
+    it "should create a template instance with the contents of the file" do
+      File.expects(:read).with("/my/template").returns "yay"
+      ERB.expects(:new).with("yay", 0, "-").returns(@template)
+
+      @wrapper.stubs :set_resource_variables
+
+      @wrapper.evaluate
+    end
+
+    it "should return the result of the template" do
+      @wrapper.stubs :set_resource_variables
+
+      @wrapper.expects(:binding).returns "mybinding"
+      @template.expects(:result).with("mybinding").returns "myresult"
+      @wrapper.evaluate.should == "myresult"
+    end
+  end
+end

data/spec/unit/util/run_mode_spec.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Util::RunMode do
+  before do
+    @run_mode = Puppet::Util::RunMode.new('fake')
+  end
+
+  it "should have confdir /etc/puppet when run as root" do
+    Puppet.features.stubs(:root?).returns(true)
+    @run_mode.conf_dir.should == '/etc/puppet'
+  end
+
+  it "should have confdir ~/.puppet when run as non-root" do
+    Puppet.features.stubs(:root?).returns(false)
+    @run_mode.expects(:expand_path).with("~/.puppet").returns("~/.puppet")
+    @run_mode.conf_dir.should == "~/.puppet"
+  end
+
+  it "should have vardir /var/lib/puppet when run as root" do
+    Puppet.features.stubs(:root?).returns(true)
+    @run_mode.var_dir.should == '/var/lib/puppet'
+  end
+
+  it "should have vardir ~/.puppet/var when run as non-root" do
+    Puppet.features.stubs(:root?).returns(false)
+    @run_mode.expects(:expand_path).with("~/.puppet/var").returns("~/.puppet/var")
+    @run_mode.var_dir.should == "~/.puppet/var"
+  end
+
+  it "should have rundir depend on vardir" do
+    @run_mode.run_dir.should == '$vardir/run'
+  end
+
+  it "should have logopts return an array with $vardir/log if runmode is not master" do
+    @run_mode.expects(:master?).returns false
+    @run_mode.logopts.should == ["$vardir/log", "The Puppet log directory."]
+  end
+
+  it "should have logopts return a hash with $vardir/log and other metadata if runmode is master" do
+    @run_mode.expects(:master?).returns true
+    @run_mode.logopts.should == {
+      :default => "$vardir/log",
+      :mode    => 0750,
+      :owner   => "service",
+      :group   => "service",
+      :desc    => "The Puppet log directory.",
+    }
+  end
+end

data/spec/unit/util/selinux_spec.rb

@@ -0,0 +1,278 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/util/selinux'
+include Puppet::Util::SELinux
+
+unless defined?(Selinux)
+  module Selinux
+    def self.is_selinux_enabled
+      false
+    end
+  end
+end
+
+describe Puppet::Util::SELinux do
+
+  describe "selinux_support?" do
+    before do
+    end
+    it "should return :true if this system has SELinux enabled" do
+      Selinux.expects(:is_selinux_enabled).returns 1
+      selinux_support?.should be_true
+    end
+
+    it "should return :false if this system lacks SELinux" do
+      Selinux.expects(:is_selinux_enabled).returns 0
+      selinux_support?.should be_false
+    end
+
+    it "should return nil if /proc/mounts does not exist" do
+      File.stubs(:open).with("/proc/mounts").raises("No such file or directory - /proc/mounts")
+      read_mounts.should == nil
+    end
+  end
+
+  describe "filesystem detection" do
+    before :each do
+      fh = stub 'fh', :close => nil
+      File.stubs(:open).with("/proc/mounts").returns fh
+      fh.expects(:read_nonblock).times(2).returns("rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n/sys /sys sysfs rw,relatime 0 0\n192.168.1.1:/var/export /mnt/nfs nfs rw,relatime,vers=3,rsize=32768,wsize=32768,namlen=255,hard,nointr,proto=tcp,timeo=600,retrans=2,sec=sys,mountaddr=192.168.1.1,mountvers=3,mountproto=udp,addr=192.168.1.1 0 0\n").then.raises EOFError
+    end
+
+    it "should parse the contents of /proc/mounts" do
+      read_mounts.should  == {
+        '/' => 'ext3',
+        '/sys' => 'sysfs',
+        '/mnt/nfs' => 'nfs',
+        '/proc' => 'proc',
+        '/dev' => 'tmpfs' }
+    end
+
+    it "should match a path on / to ext3" do
+      find_fs('/etc/puppet/testfile').should == "ext3"
+    end
+
+    it "should match a path on /mnt/nfs to nfs" do
+      find_fs('/mnt/nfs/testfile/foobar').should == "nfs"
+    end
+
+    it "should reture true for a capable filesystem" do
+      selinux_label_support?('/etc/puppet/testfile').should be_true
+    end
+
+    it "should return false for a noncapable filesystem" do
+      selinux_label_support?('/mnt/nfs/testfile').should be_false
+    end
+
+    it "should follow symlinks when determining file systems" do
+      self.stubs(:realpath).with('/mnt/symlink/testfile').returns('/mnt/nfs/dest/testfile')
+
+      selinux_label_support?('/mnt/symlink/testfile').should be_false
+    end
+
+  end
+
+  describe "realpath" do
+    it "should handle files that don't exist" do
+
+      # Since I'm stubbing Pathname.new for this test,
+      # I need to also stub the internal calls to Pathname.new,
+      # which happen in Pathname.dirname and Parthname.basename
+      # I want those to return real Pathname objects,
+      # so I'm creating them before the stub is in place.
+      realpaths = Hash.new {|hash, path| hash[path] = Pathname.new(path) }
+      paths = ['symlink', '/mnt']
+      paths.each { |path| realpaths[path] }
+
+      realpaths['/mnt/symlink'] = stubs "Pathname"
+      realpaths['/mnt/symlink'].stubs(:realpath).returns(realpaths['/mnt/nfs/dest'])
+      realpaths['/mnt/symlink'].stubs(:exist?).returns(true)
+
+      realpaths['/mnt/symlink/nonexistant'] = stubs "Pathname"
+      realpaths['/mnt/symlink/nonexistant'].stubs(:realpath).raises(Errno::ENOENT)
+      realpaths['/mnt/symlink/nonexistant'].stubs(:exist?).returns(false)
+      realpaths['/mnt/symlink/nonexistant'].stubs(:dirname).returns(realpaths['/mnt/symlink'])
+      realpaths['/mnt/symlink/nonexistant'].stubs(:basename).returns(realpaths['nonexistant'])
+
+      realpaths.each do |path, value|
+        Pathname.stubs(:new).with(path).returns(value)
+      end
+
+      realpath('/mnt/symlink/nonexistant').should == '/mnt/nfs/dest/nonexistant'
+    end
+  end
+
+  describe "get_selinux_current_context" do
+    it "should return nil if no SELinux support" do
+      self.expects(:selinux_support?).returns false
+      get_selinux_current_context("/foo").should be_nil
+    end
+
+    it "should return a context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:type_t:s0"]
+      get_selinux_current_context("/foo").should == "user_u:role_r:type_t:s0"
+    end
+
+    it "should return nil if lgetfilecon fails" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns -1
+      get_selinux_current_context("/foo").should be_nil
+    end
+  end
+
+  describe "get_selinux_default_context" do
+    it "should return nil if no SELinux support" do
+      self.expects(:selinux_support?).returns false
+      get_selinux_default_context("/foo").should be_nil
+    end
+
+    it "should return a context if a default context exists" do
+      self.expects(:selinux_support?).returns true
+      fstat = stub 'File::Stat', :mode => 0
+      File.expects(:lstat).with("/foo").returns fstat
+      self.expects(:find_fs).with("/foo").returns "ext3"
+      Selinux.expects(:matchpathcon).with("/foo", 0).returns [0, "user_u:role_r:type_t:s0"]
+      get_selinux_default_context("/foo").should == "user_u:role_r:type_t:s0"
+    end
+
+    it "should return nil if matchpathcon returns failure" do
+      self.expects(:selinux_support?).returns true
+      fstat = stub 'File::Stat', :mode => 0
+      File.expects(:lstat).with("/foo").returns fstat
+      self.expects(:find_fs).with("/foo").returns "ext3"
+      Selinux.expects(:matchpathcon).with("/foo", 0).returns -1
+      get_selinux_default_context("/foo").should be_nil
+    end
+
+    it "should return nil if selinux_label_support returns false" do
+      self.expects(:selinux_support?).returns true
+      self.expects(:find_fs).with("/foo").returns "nfs"
+      get_selinux_default_context("/foo").should be_nil
+    end
+
+  end
+
+  describe "parse_selinux_context" do
+    it "should return nil if no context is passed" do
+      parse_selinux_context(:seluser, nil).should be_nil
+    end
+
+    it "should return nil if the context is 'unlabeled'" do
+      parse_selinux_context(:seluser, "unlabeled").should be_nil
+    end
+
+    it "should return the user type when called with :seluser" do
+      parse_selinux_context(:seluser, "user_u:role_r:type_t:s0").should == "user_u"
+    end
+
+    it "should return the role type when called with :selrole" do
+      parse_selinux_context(:selrole, "user_u:role_r:type_t:s0").should == "role_r"
+    end
+
+    it "should return the type type when called with :seltype" do
+      parse_selinux_context(:seltype, "user_u:role_r:type_t:s0").should == "type_t"
+    end
+
+    it "should return nil for :selrange when no range is returned" do
+      parse_selinux_context(:selrange, "user_u:role_r:type_t").should be_nil
+    end
+
+    it "should return the range type when called with :selrange" do
+      parse_selinux_context(:selrange, "user_u:role_r:type_t:s0").should == "s0"
+    end
+
+    describe "with a variety of SELinux range formats" do
+      ['s0', 's0:c3', 's0:c3.c123', 's0:c3,c5,c8', 'TopSecret', 'TopSecret,Classified', 'Patient_Record'].each do |range|
+        it "should parse range '#{range}'" do
+          parse_selinux_context(:selrange, "user_u:role_r:type_t:#{range}").should == range
+        end
+      end
+    end
+  end
+
+  describe "set_selinux_context" do
+    before :each do
+      fh = stub 'fh', :close => nil
+      File.stubs(:open).with("/proc/mounts").returns fh
+      fh.stubs(:read_nonblock).returns(
+        "rootfs / rootfs rw 0 0\n/dev/root / ext3 rw,relatime,errors=continue,user_xattr,acl,data=ordered 0 0\n"+
+        "/dev /dev tmpfs rw,relatime,mode=755 0 0\n/proc /proc proc rw,relatime 0 0\n"+
+        "/sys /sys sysfs rw,relatime 0 0\n"
+        ).then.raises EOFError
+    end
+
+    it "should return nil if there is no SELinux support" do
+      self.expects(:selinux_support?).returns false
+      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_nil
+    end
+
+    it "should return nil if selinux_label_support returns false" do
+      self.expects(:selinux_support?).returns true
+      self.expects(:selinux_label_support?).with("/foo").returns false
+      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_nil
+    end
+
+    it "should use lsetfilecon to set a context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      set_selinux_context("/foo", "user_u:role_r:type_t:s0").should be_true
+    end
+
+    it "should use lsetfilecon to set user_u user context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "foo:role_r:type_t:s0"]
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      set_selinux_context("/foo", "user_u", :seluser).should be_true
+    end
+
+    it "should use lsetfilecon to set role_r role context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:foo:type_t:s0"]
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      set_selinux_context("/foo", "role_r", :selrole).should be_true
+    end
+
+    it "should use lsetfilecon to set type_t type context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:foo:s0"]
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0").returns 0
+      set_selinux_context("/foo", "type_t", :seltype).should be_true
+    end
+
+    it "should use lsetfilecon to set s0:c3,c5 range context" do
+      self.expects(:selinux_support?).returns true
+      Selinux.expects(:lgetfilecon).with("/foo").returns [0, "user_u:role_r:type_t:s0"]
+      Selinux.expects(:lsetfilecon).with("/foo", "user_u:role_r:type_t:s0:c3,c5").returns 0
+      set_selinux_context("/foo", "s0:c3,c5", :selrange).should be_true
+    end
+  end
+
+  describe "set_selinux_default_context" do
+    it "should return nil if there is no SELinux support" do
+      self.expects(:selinux_support?).returns false
+      set_selinux_default_context("/foo").should be_nil
+    end
+
+    it "should return nil if no default context exists" do
+      self.expects(:get_selinux_default_context).with("/foo").returns nil
+      set_selinux_default_context("/foo").should be_nil
+    end
+
+    it "should do nothing and return nil if the current context matches the default context" do
+      self.expects(:get_selinux_default_context).with("/foo").returns "user_u:role_r:type_t"
+      self.expects(:get_selinux_current_context).with("/foo").returns "user_u:role_r:type_t"
+      set_selinux_default_context("/foo").should be_nil
+    end
+
+    it "should set and return the default context if current and default do not match" do
+      self.expects(:get_selinux_default_context).with("/foo").returns "user_u:role_r:type_t"
+      self.expects(:get_selinux_current_context).with("/foo").returns "olduser_u:role_r:type_t"
+      self.expects(:set_selinux_context).with("/foo", "user_u:role_r:type_t").returns true
+      set_selinux_default_context("/foo").should == "user_u:role_r:type_t"
+    end
+  end
+
+end