puppet 0.25.5 → 2.6.0

data/test/lib/puppettest/certificates.rb

@@ -3,58 +3,56 @@
 require 'puppettest'
 
 module PuppetTest::Certificates
-    include PuppetTest
-
-    def mkPassFile()
-        keyfile = File.join(@dir, "tmpkeyfile")
-        @@tmpfiles << keyfile
-        unless FileTest.exists?(@dir)
-            system("mkdir -p %s" % @dir)
-        end
-        File.open(keyfile, "w", 0600) { |f|
-            f.print "as;dklj23rlkjzdflij23wr"
-        }
-
-        return keyfile
-    end
-
-    def mkCA
-        ca = nil
-        assert_nothing_raised {
-            ca = Puppet::SSLCertificates::CA.new()
-        }
-
-        return ca
-    end
-
-    def mkStore(ca)
-        store = OpenSSL::X509::Store.new
-        store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
-        store.flags = OpenSSL::X509::V_FLAG_CRL_CHECK
-        store.add_cert(ca.cert)
-        store.add_crl(ca.crl)
-        store
-    end
-
-    def mkcert(hostname)
-        cert = nil
-        assert_nothing_raised {
-            cert = Puppet::SSLCertificates::Certificate.new(:name => hostname)
-            cert.mkcsr
-        }
-
-        return cert
-    end
-
-    def mksignedcert(ca = nil, hostname = nil)
-        ca ||= mkCA()
-        hostname ||= "ttltest.example.com"
-
-        cert = nil
-        assert_nothing_raised {
-            cert, cacert = ca.sign(mkcert(hostname).mkcsr)
-        }
-        return cert
-    end
+  include PuppetTest
+
+  def mkPassFile()
+    keyfile = File.join(@dir, "tmpkeyfile")
+    @@tmpfiles << keyfile
+    system("mkdir -p #{@dir}") unless FileTest.exists?(@dir)
+    File.open(keyfile, "w", 0600) { |f|
+      f.print "as;dklj23rlkjzdflij23wr"
+    }
+
+    keyfile
+  end
+
+  def mkCA
+    ca = nil
+    assert_nothing_raised {
+      ca = Puppet::SSLCertificates::CA.new
+    }
+
+    ca
+  end
+
+  def mkStore(ca)
+    store = OpenSSL::X509::Store.new
+    store.purpose = OpenSSL::X509::PURPOSE_SSL_CLIENT
+    store.flags = OpenSSL::X509::V_FLAG_CRL_CHECK
+    store.add_cert(ca.cert)
+    store.add_crl(ca.crl)
+    store
+  end
+
+  def mkcert(hostname)
+    cert = nil
+    assert_nothing_raised {
+      cert = Puppet::SSLCertificates::Certificate.new(:name => hostname)
+      cert.mkcsr
+    }
+
+    cert
+  end
+
+  def mksignedcert(ca = nil, hostname = nil)
+    ca ||= mkCA()
+    hostname ||= "ttltest.example.com"
+
+    cert = nil
+    assert_nothing_raised {
+      cert, cacert = ca.sign(mkcert(hostname).mkcsr)
+    }
+    cert
+  end
 end
 

data/test/lib/puppettest/exetest.rb

@@ -1,129 +1,125 @@
 require 'puppettest/servertest'
 
 module PuppetTest::ExeTest
-    include PuppetTest::ServerTest
-
-    def setup
-        super
-        setbindir
-        setlibdir
+  include PuppetTest::ServerTest
+
+  def setup
+    super
+    setbindir
+    setlibdir
+  end
+
+  def bindir
+    File.join(basedir, "bin")
+  end
+
+  def sbindir
+    File.join(basedir, "sbin")
+  end
+
+  def setbindir
+    ENV["PATH"] = [bindir, ENV["PATH"]].join(":") unless ENV["PATH"].split(":").include?(bindir)
+    ENV["PATH"] = [sbindir, ENV["PATH"]].join(":") unless ENV["PATH"].split(":").include?(sbindir)
+  end
+
+  def setlibdir
+    ENV["RUBYLIB"] = $LOAD_PATH.find_all { |dir|
+      dir =~ /puppet/ or dir =~ /\.\./
+    }.join(":")
+  end
+
+  # Run a ruby command.  This explicitly uses ruby to run stuff, since we
+  # don't necessarily know where our ruby binary is, dernit.
+  # Currently unused, because I couldn't get it to work.
+  def rundaemon(*cmd)
+    @ruby ||= %x{which ruby}.chomp
+    cmd = cmd.unshift(@ruby).join(" ")
+
+    out = nil
+    Dir.chdir(bindir) {
+      out = %x{#{@ruby} #{cmd}}
+    }
+    out
+  end
+
+  def startmasterd(args = "")
+    output = nil
+
+    manifest = mktestmanifest
+    args += " --manifest #{manifest}"
+    args += " --confdir #{Puppet[:confdir]}"
+    args += " --rundir #{File.join(Puppet[:vardir], "run")}"
+    args += " --vardir #{Puppet[:vardir]}"
+    args += " --certdnsnames #{Puppet[:certdnsnames]}"
+    args += " --masterport #{@@port}"
+    args += " --user #{Puppet::Util::SUIDManager.uid}"
+    args += " --group #{Puppet::Util::SUIDManager.gid}"
+    args += " --autosign true"
+
+    #if Puppet[:debug]
+    #    args += " --debug"
+    #end
+
+    cmd = "puppetmasterd #{args}"
+
+
+    assert_nothing_raised {
+      output = %x{#{cmd}}.chomp
+    }
+    assert_equal("", output, "Puppetmasterd produced output #{output}")
+    assert($CHILD_STATUS == 0, "Puppetmasterd exit status was #{$CHILD_STATUS}")
+    sleep(1)
+
+    cleanup do
+      stopmasterd
+      sleep(1)
     end
 
-    def bindir
-        File.join(basedir, "bin")
-    end
+    manifest
+  end
 
-    def sbindir
-        File.join(basedir, "sbin")
-    end
+  def stopmasterd(running = true)
+    ps = Facter["ps"].value || "ps -ef"
 
-    def setbindir
-        unless ENV["PATH"].split(":").include?(bindir)
-            ENV["PATH"] = [bindir, ENV["PATH"]].join(":")
-        end
-        unless ENV["PATH"].split(":").include?(sbindir)
-            ENV["PATH"] = [sbindir, ENV["PATH"]].join(":")
-        end
-    end
-
-    def setlibdir
-        ENV["RUBYLIB"] = $:.find_all { |dir|
-            dir =~ /puppet/ or dir =~ /\.\./
-        }.join(":")
-    end
+    pidfile = File.join(Puppet[:vardir], "run", "puppetmasterd.pid")
 
-    # Run a ruby command.  This explicitly uses ruby to run stuff, since we
-    # don't necessarily know where our ruby binary is, dernit.
-    # Currently unused, because I couldn't get it to work.
-    def rundaemon(*cmd)
-        @ruby ||= %x{which ruby}.chomp
-        cmd = cmd.unshift(@ruby).join(" ")
-
-        out = nil
-        Dir.chdir(bindir()) {
-            out = %x{#{@ruby} #{cmd}}
-        }
-        return out
+    pid = nil
+    if FileTest.exists?(pidfile)
+      pid = File.read(pidfile).chomp.to_i
+      File.unlink(pidfile)
     end
 
-    def startmasterd(args = "")
-        output = nil
-
-        manifest = mktestmanifest()
-        args += " --manifest %s" % manifest
-        args += " --confdir %s" % Puppet[:confdir]
-        args += " --rundir %s" % File.join(Puppet[:vardir], "run")
-        args += " --vardir %s" % Puppet[:vardir]
-        args += " --certdnsnames %s" % Puppet[:certdnsnames]
-        args += " --masterport %s" % @@port
-        args += " --user %s" % Puppet::Util::SUIDManager.uid
-        args += " --group %s" % Puppet::Util::SUIDManager.gid
-        args += " --autosign true"
-
-        #if Puppet[:debug]
-        #    args += " --debug"
-        #end
-
-        cmd = "puppetmasterd %s" % args
-
-
-        assert_nothing_raised {
-            output = %x{#{cmd}}.chomp
-        }
-        assert_equal("", output, "Puppetmasterd produced output %s" % output)
-        assert($? == 0, "Puppetmasterd exit status was %s" % $?)
-        sleep(1)
-
-        cleanup do
-            stopmasterd
-            sleep(1)
+    return unless running
+    if running or pid
+      runningpid = nil
+      %x{#{ps}}.chomp.split(/\n/).each { |line|
+        if line =~ /ruby.+puppetmasterd/
+          next if line =~ /\.rb/ # skip the test script itself
+          next if line =~ /^puppet/ # skip masters running as 'puppet'
+          ary = line.sub(/^\s+/, '').split(/\s+/)
+          pid = ary[1].to_i
         end
+      }
 
-        return manifest
     end
 
-    def stopmasterd(running = true)
-        ps = Facter["ps"].value || "ps -ef"
-
-        pidfile = File.join(Puppet[:vardir], "run", "puppetmasterd.pid")
-
-        pid = nil
-        if FileTest.exists?(pidfile)
-            pid = File.read(pidfile).chomp.to_i
-            File.unlink(pidfile)
-        end
-
-        return unless running
-        if running or pid
-            runningpid = nil
-            %x{#{ps}}.chomp.split(/\n/).each { |line|
-                if line =~ /ruby.+puppetmasterd/
-                    next if line =~ /\.rb/ # skip the test script itself
-                    next if line =~ /^puppet/ # skip masters running as 'puppet'
-                    ary = line.sub(/^\s+/, '').split(/\s+/)
-                    pid = ary[1].to_i
-                end
-            }
-
-        end
-
-        # we default to mandating that it's running, but teardown
-        # doesn't require that
-        if pid
-            if pid == $$
-                raise Puppet::Error, "Tried to kill own pid"
-            end
-            begin
-                Process.kill(:INT, pid)
-            rescue
-                # ignore it
-            end
-        end
+    # we default to mandating that it's running, but teardown
+    # doesn't require that
+    if pid
+      if pid == $PID
+        raise Puppet::Error, "Tried to kill own pid"
+      end
+      begin
+        Process.kill(:INT, pid)
+      rescue
+        # ignore it
+      end
     end
+  end
 
-    def teardown
-        stopmasterd(false)
-        super
-    end
+  def teardown
+    stopmasterd(false)
+    super
+  end
 end
 

data/test/lib/puppettest/fakes.rb

@@ -1,204 +1,199 @@
 require 'puppettest'
 
 module PuppetTest
-    # A baseclass for the faketypes.
-    class FakeModel
-        include Puppet::Util
-        class << self
-            attr_accessor :name, :realresource
-            @name = :fakeresource
-        end
-
-        def self.namevar
-            @realresource.namevar
-        end
+  # A baseclass for the faketypes.
+  class FakeModel
+    include Puppet::Util
+    class << self
+      attr_accessor :name, :realresource
+      @name = :fakeresource
+    end
 
-        def self.validproperties
-            Puppet::Type.type(@name).validproperties
-        end
+    def self.key_attributes
+      @realresource.key_attributes
+    end
 
-        def self.validproperty?(name)
-            Puppet::Type.type(@name).validproperty?(name)
-        end
+    def self.validproperties
+      Puppet::Type.type(@name).validproperties
+    end
 
-        def self.to_s
-            "Fake%s" % @name.to_s.capitalize
-        end
+    def self.validproperty?(name)
+      Puppet::Type.type(@name).validproperty?(name)
+    end
 
-        def [](param)
-            if @realresource.attrtype(param) == :property
-                @is[param]
-            else
-                @params[param]
-            end
-        end
+    def self.to_s
+      "Fake#{@name.to_s.capitalize}"
+    end
 
-        def []=(param, value)
-            param = symbolize(param)
-            unless @realresource.validattr?(param)
-                raise Puppet::DevError, "Invalid attribute %s for %s" %
-                    [param, @realresource.name]
-            end
-            if @realresource.attrtype(param) == :property
-                @should[param] = value
-            else
-                @params[param] = value
-            end
-        end
+    def [](param)
+      if @realresource.attrtype(param) == :property
+        @is[param]
+      else
+        @params[param]
+      end
+    end
 
-        def initialize(name)
-            @realresource = Puppet::Type.type(self.class.name)
-            raise "Could not find type #{self.class.name}" unless @realresource
-            @is = {}
-            @should = {}
-            @params = {}
-            self[@realresource.namevar] = name
-        end
+    def []=(param, value)
+      param = symbolize(param)
+      raise Puppet::DevError, "Invalid attribute #{param} for #{@realresource.name}" unless @realresource.valid_parameter?(param)
+      if @realresource.attrtype(param) == :property
+        @should[param] = value
+      else
+        @params[param] = value
+      end
+    end
 
-        def inspect
-            "%s(%s)" % [self.class.to_s.sub(/.+::/, ''), super()]
-        end
+    def initialize(name)
+      @realresource = Puppet::Type.type(self.class.name)
+      raise "Could not find type #{self.class.name}" unless @realresource
+      @is = {}
+      @should = {}
+      @params = {}
+      self[@realresource.key_attributes.first] = name
+    end
 
-        def is(param)
-            @is[param]
-        end
+    def inspect
+      "#{self.class.to_s.sub(/.+::/, '')}(#{super()})"
+    end
 
-        def should(param)
-            @should[param]
-        end
+    def is(param)
+      @is[param]
+    end
 
-        def to_hash
-            hash = @params.dup
-            [@is, @should].each do |h|
-                h.each do |p, v|
-                    hash[p] = v
-                end
-            end
-            hash
-        end
+    def should(param)
+      @should[param]
+    end
 
-        def name
-            self[:name]
+    def to_hash
+      hash = @params.dup
+      [@is, @should].each do |h|
+        h.each do |p, v|
+          hash[p] = v
         end
+      end
+      hash
     end
 
-    class FakeProvider
-        attr_accessor :resource
-        class << self
-            attr_accessor :name, :resource_type, :methods
-        end
+    def name
+      self[:name]
+    end
+  end
 
-        # A very low number, so these never show up as defaults via the standard
-        # algorithms.
-        def self.defaultnum
-            -50
-        end
+  class FakeProvider
+    attr_accessor :resource
+    class << self
+      attr_accessor :name, :resource_type, :methods
+    end
 
-        # Set up methods to fake things
-        def self.apimethods(*ary)
-            @resource_type.validproperties.each do |property|
-                ary << property unless ary.include? property
-            end
-            attr_accessor(*ary)
+    # A very low number, so these never show up as defaults via the standard
+    # algorithms.
+    def self.defaultnum
+      -50
+    end
 
-            @methods = ary
-        end
+    # Set up methods to fake things
+    def self.apimethods(*ary)
+      @resource_type.validproperties.each do |property|
+        ary << property unless ary.include? property
+      end
+      attr_accessor(*ary)
 
-        def self.default?
-            false
-        end
+      @methods = ary
+    end
 
-        def self.initvars
-            @calls = Hash.new do |hash, key|
-                hash[key] = 0
-            end
-        end
+    def self.default?
+      false
+    end
 
-        def self.source
-            self.name
-        end
+    def self.initvars
+      @calls = Hash.new do |hash, key|
+        hash[key] = 0
+      end
+    end
 
-        def self.supports_parameter?(param)
-            true
-        end
+    def self.source
+      self.name
+    end
 
-        def self.suitable?
-            true
-        end
+    def self.supports_parameter?(param)
+      true
+    end
 
-        def clear
-            @resource = nil
-        end
+    def self.suitable?
+      true
+    end
 
-        def initialize(resource)
-            @resource = resource
-        end
+    def clear
+      @resource = nil
+    end
 
-        def properties
-            self.class.resource_type.validproperties.inject({}) do |props, name|
-                props[name] = self.send(name) || :absent
-                props
-            end
-        end
+    def initialize(resource)
+      @resource = resource
     end
 
-    class FakeParsedProvider < FakeProvider
-        def hash
-            ret = {}
-            instance_variables.each do |v|
-                v = v.sub("@", '')
-                if val = self.send(v)
-                    ret[v.intern] = val
-                end
-            end
+    def properties
+      self.class.resource_type.validproperties.inject({}) do |props, name|
+        props[name] = self.send(name) || :absent
+        props
+      end
+    end
+  end
 
-            return ret
+  class FakeParsedProvider < FakeProvider
+    def hash
+      ret = {}
+      instance_variables.each do |v|
+        v = v.sub("@", '')
+        if val = self.send(v)
+          ret[v.intern] = val
         end
+      end
 
-        def store(hash)
-            hash.each do |n, v|
-                method = n.to_s + "="
-                if respond_to? method
-                    send(method, v)
-                end
-            end
-        end
+      ret
     end
 
-    @@fakeresources = {}
-    @@fakeproviders = {}
+    def store(hash)
+      hash.each do |n, v|
+        method = n.to_s + "="
+        send(method, v) if respond_to? method
+      end
+    end
+  end
 
-    def fakeresource(type, name, options = {})
-        type = type.intern if type.is_a? String
-        unless @@fakeresources.include? type
-            @@fakeresources[type] = Class.new(FakeModel)
-            @@fakeresources[type].name = type
+  @@fakeresources = {}
+  @@fakeproviders = {}
 
-            resource = Puppet::Type.type(type)
-            raise("Could not find type %s" % type) unless resource
-            @@fakeresources[type].realresource = resource
-        end
+  def fakeresource(type, name, options = {})
+    type = type.intern if type.is_a? String
+    unless @@fakeresources.include? type
+      @@fakeresources[type] = Class.new(FakeModel)
+      @@fakeresources[type].name = type
 
-        obj = @@fakeresources[type].new(name)
-        options.each do |name, val|
-            obj[name] = val
-        end
-        obj
+      resource = Puppet::Type.type(type)
+      raise("Could not find type #{type}") unless resource
+      @@fakeresources[type].realresource = resource
     end
 
-    module_function :fakeresource
+    obj = @@fakeresources[type].new(name)
+    options.each do |name, val|
+      obj[name] = val
+    end
+    obj
+  end
 
-    def fakeprovider(type, resource)
-        type = type.intern if type.is_a? String
-        unless @@fakeproviders.include? type
-            @@fakeproviders[type] = Class.new(FakeModel) do
-                @name = type
-            end
-        end
+  module_function :fakeresource
 
-        @@fakeproviders[type].new(resource)
+  def fakeprovider(type, resource)
+    type = type.intern if type.is_a? String
+    unless @@fakeproviders.include? type
+      @@fakeproviders[type] = Class.new(FakeModel) do
+        @name = type
+      end
     end
 
-    module_function :fakeprovider
+    @@fakeproviders[type].new(resource)
+  end
+
+  module_function :fakeprovider
 end