puppet 2.7.26 → 3.0.0.rc4

data/test/lib/puppettest/resourcetesting.rb

@@ -1,54 +0,0 @@
-module PuppetTest::ResourceTesting
-  Parser = Puppet::Parser
-  AST = Puppet::Parser::AST
-
-  def mkevaltest(parser = nil)
-    parser ||= mkparser
-
-          @parser.newdefine(
-        "evaltest",
-        
-      :arguments => [%w{one}, ["two", stringobj("755")]],
-
-            :code => resourcedef(
-        "file", "/tmp",
-        
-        "owner" => varref("one"), "mode" => varref("two"))
-    )
-  end
-
-  def mkresource(args = {})
-    args[:source] ||= "source"
-    args[:scope] ||= mkscope
-
-    type = args[:type] || "resource"
-    title = args[:title] || "testing"
-    args.delete(:type)
-    args.delete(:title)
-    {:source => "source", :scope => "scope"}.each do |param, value|
-      args[param] ||= value
-    end
-
-    params = args[:parameters] || {:one => "yay", :three => "rah"}
-    if args[:parameters] == :none
-      args.delete(:parameters)
-    else
-      args[:parameters] = paramify args[:source], params
-    end
-
-    Parser::Resource.new(type, title, args)
-  end
-
-  def param(name, value, source)
-    Parser::Resource::Param.new(:name => name, :value => value, :source => source)
-  end
-
-  def paramify(source, hash)
-    hash.collect do |name, value|
-      Parser::Resource::Param.new(
-        :name => name, :value => value, :source => source
-      )
-    end
-  end
-end
-

data/test/lib/puppettest/runnable_test.rb

@@ -1,43 +0,0 @@
-# Manage whether a test is runnable.
-module PuppetTest
-  module RunnableTest
-    # Confine this example group based on specified criteria.  This can be
-    # a message and its related test either as a hash or as a single
-    # message argument and a block to be evaluated at the time the confine
-    # is checked.
-    #
-    # Examples:
-    #
-    # confine "Rails is not available" => Puppet.features.rails?
-    #
-    # confine("ActiveRecord 2.1.x") { ::ActiveRecord::VERSION::MAJOR == 2 and ::ActiveRecord::VERSION::MINOR <= 1 }
-    #
-    def confine(hash_or_message, &block)
-      hash = block_given? ? {hash_or_message => block} : hash_or_message
-      confines.update hash
-    end
-
-    # Check all confines for a given example group, starting with any
-    # specified in the parent example group. If any confine test is false,
-    # the example group is not runnable (and will be skipped). Note: This
-    # is used directly by Rspec and is not intended for develper use.
-    #
-    def runnable?
-      return false if superclass.respond_to?(:runnable?) and not superclass.runnable?
-
-      confines.each do |message, is_runnable|
-        is_runnable = is_runnable.call if is_runnable.respond_to?(:call)
-        messages << message unless is_runnable
-      end
-
-      messages.empty?
-    end
-
-    def messages; @messages ||= [] end
-
-    private
-
-    def confines; @confines ||= {} end
-  end
-
-end

data/test/lib/puppettest/servertest.rb

@@ -1,77 +0,0 @@
-require 'puppettest'
-
-module PuppetTest::ServerTest
-  include PuppetTest
-  def setup
-    super
-
-    if defined?(@@port)
-      @@port += 1
-    else
-      @@port = 20000
-    end
-  end
-
-  # create a simple manifest that just creates a file
-  def mktestmanifest
-    file = File.join(Puppet[:confdir], "#{(self.class.to_s + "test")}site.pp")
-    #@createdfile = File.join(tmpdir, self.class.to_s + "manifesttesting" +
-    #    "_#{@method_name}")
-    @createdfile = tempfile
-
-    File.open(file, "w") { |f|
-      f.puts "file { \"%s\": ensure => file, mode => 755 }\n" % @createdfile
-    }
-
-    @@tmpfiles << @createdfile
-    @@tmpfiles << file
-
-    file
-  end
-
-  # create a server, forked into the background
-  def mkserver(handlers = nil)
-    # The defaults make for very slow tests.
-    Puppet[:req_bits]  = 512
-    Puppet[:keylength] = 512
-
-    Puppet[:name] = "puppetmasterd"
-    # our default handlers
-    unless handlers
-      handlers = {
-        :CA => {}, # so that certs autogenerate
-        :Master => {
-          :Manifest => mktestmanifest,
-          :UseNodes => false
-        },
-      }
-    end
-
-    # then create the actual server
-    server = nil
-    assert_nothing_raised {
-
-            server = Puppet::Network::HTTPServer::WEBrick.new(
-                
-        :Port => @@port,
-        
-        :Handlers => handlers
-      )
-    }
-
-    # fork it
-    spid = fork {
-      trap(:INT) { server.shutdown }
-      server.start
-    }
-
-    # and store its pid for killing
-    @@tmppids << spid
-
-    # give the server a chance to do its thing
-    sleep 1
-    spid
-  end
-
-end
-

data/test/lib/puppettest/support.rb

@@ -1,8 +0,0 @@
-require 'puppettest'
-
-module PuppetTest::Support
-end
-
-require 'puppettest/support/assertions'
-require 'puppettest/support/helpers'
-require 'puppettest/support/utils'

data/test/lib/puppettest/support/assertions.rb

@@ -1,69 +0,0 @@
-require 'puppettest/support/utils'
-require 'fileutils'
-
-module PuppetTest
-  include PuppetTest::Support::Utils
-  def assert_logged(level, regex, msg = nil)
-    # Skip verifying logs that we're not supposed to send.
-    return unless Puppet::Util::Log.sendlevel?(level)
-    r = @logs.detect { |l| l.level == level and l.message =~ regex }
-    @logs.clear
-    assert(r, msg)
-  end
-
-  def assert_uid_gid(uid, gid, filename)
-    flunk "Must be uid 0 to run these tests" unless Process.uid == 0
-
-    fork do
-      Puppet::Util::SUIDManager.gid = gid
-      Puppet::Util::SUIDManager.uid = uid
-      # FIXME: use the tempfile method from puppettest.rb
-      system("mkfifo #{filename}")
-      f = File.open(filename, "w")
-      f << "#{Puppet::Util::SUIDManager.uid}\n#{Puppet::Util::SUIDManager.gid}\n"
-      yield if block_given?
-    end
-
-    # avoid a race.
-    true while !File.exists? filename
-
-    f = File.open(filename, "r")
-
-    a = f.readlines
-    assert_equal(uid, a[0].chomp.to_i, "UID was incorrect")
-    assert_equal(gid, a[1].chomp.to_i, "GID was incorrect")
-    FileUtils.rm(filename)
-  end
-
-  def assert_events(events, *resources)
-    trans = nil
-    comp = nil
-    msg = nil
-
-    raise Puppet::DevError, "Incorrect call of assert_events" unless events.is_a? Array
-    msg = resources.pop if resources[-1].is_a? String
-
-    config = resources2catalog(*resources)
-    transaction = Puppet::Transaction.new(config)
-
-    transaction.evaluate
-    newevents = transaction.events.
-      reject { |e| ['failure', 'audit'].include? e.status }.
-      collect { |e| e.name }
-
-    assert_equal(events, newevents, "Incorrect evaluate #{msg} events")
-
-    transaction
-  end
-
-  # A simpler method that just applies what we have.
-  def assert_apply(*resources)
-    config = resources2catalog(*resources)
-
-    events = nil
-    assert_nothing_raised("Failed to evaluate") {
-      events = config.apply.events
-    }
-    events
-  end
-end

data/test/lib/puppettest/support/helpers.rb

@@ -1,18 +0,0 @@
-require 'puppettest'
-
-module PuppetTest
-  # NOTE: currently both of these will produce bogus results on Darwin due to the wonderful
-  # UID of nobody.
-  def nonrootuser
-    Etc.passwd { |user|
-      return user if user.uid != Puppet::Util::SUIDManager.uid and user.uid > 0 and user.uid < 255
-    }
-  end
-
-  def nonrootgroup
-    Etc.group { |group|
-      return group if group.gid != Puppet::Util::SUIDManager.gid and group.gid > 0 and group.gid < 255
-    }
-  end
-end
-

data/test/lib/puppettest/support/resources.rb

@@ -1,31 +0,0 @@
-#!/usr/bin/env ruby
-module PuppetTest::Support::Resources
-  def tree_resource(name)
-    Puppet::Type.type(:file).new :title => name, :path => "/tmp/#{name}", :mode => 0755
-  end
-
-  def tree_container(name)
-    Puppet::Type::Component.create :name => name, :type => "yay"
-  end
-
-  def treenode(config, name, *resources)
-    comp = tree_container name
-    resources.each do |resource|
-      resource = tree_resource(resource) if resource.is_a?(String)
-      config.add_edge(comp, resource)
-      config.add_resource resource unless config.resource(resource.ref)
-    end
-    comp
-  end
-
-  def mktree
-    catalog = Puppet::Resource::Catalog.new do |config|
-      one = treenode(config, "one", "a", "b")
-      two = treenode(config, "two", "c", "d")
-      middle = treenode(config, "middle", "e", "f", two)
-      top = treenode(config, "top", "g", "h", middle, one)
-    end
-
-    catalog
-  end
-end

data/test/lib/puppettest/support/utils.rb

@@ -1,141 +0,0 @@
-module PuppetTest::Support
-end
-module PuppetTest::Support::Utils
-  def gcdebug(type)
-    Puppet.warning "#{type}: #{ObjectSpace.each_object(type) { |o| }}"
-  end
-
-  def basedir(*list)
-    unless defined? @@basedir
-      Dir.chdir(File.dirname(__FILE__)) do
-        @@basedir = File.dirname(File.dirname(File.dirname(File.dirname(Dir.getwd))))
-      end
-    end
-    if list.empty?
-      @@basedir
-    else
-      File.join(@@basedir, *list)
-    end
-  end
-
-  def fakedata(dir,pat='*')
-    glob = "#{basedir}/test/#{dir}/#{pat}"
-    files = Dir.glob(glob,File::FNM_PATHNAME)
-    raise Puppet::DevError, "No fakedata matching #{glob}" if files.empty?
-    files
-  end
-
-  def datadir(*list)
-    File.join(basedir, "test", "data", *list)
-  end
-
-  #
-  # TODO: I think this method needs to be renamed to something a little more
-  # explanatory.
-  #
-
-  def newobj(type, name, hash)
-    transport = Puppet::TransObject.new(name, "file")
-    transport[:path] = path
-    transport[:ensure] = "file"
-    assert_nothing_raised {
-      file = transport.to_ral
-    }
-  end
-
-  # Turn a list of resources, or possibly a catalog and some resources,
-  # into a catalog object.
-  def resources2catalog(*resources)
-    if resources[0].is_a?(Puppet::Resource::Catalog)
-      config = resources.shift
-      resources.each { |r| config.add_resource r } unless resources.empty?
-    elsif resources[0].is_a?(Puppet::Type.type(:component))
-      raise ArgumentError, "resource2config() no longer accpts components"
-      comp = resources.shift
-      comp.delve
-    else
-      config = Puppet::Resource::Catalog.new
-      resources.each { |res| config.add_resource res }
-    end
-    config
-  end
-
-  # TODO: rewrite this to use the 'etc' module.
-
-  # Define a variable that contains the name of my user.
-  def setme
-    # retrieve the user name
-    id = %x{id}.chomp
-    if id =~ /uid=\d+\(([^\)]+)\)/
-      @me = $1
-    else
-      puts id
-    end
-    raise "Could not retrieve user name; 'id' did not work" unless defined?(@me)
-  end
-
-  # Define a variable that contains a group I'm in.
-  def set_mygroup
-    # retrieve the user name
-    group = %x{groups}.chomp.split(/ /)[0]
-    raise "Could not find group to set in @mygroup" unless group
-    @mygroup = group
-  end
-
-  def fakefile(name)
-    ary = [basedir, "test"]
-    ary += name.split("/")
-    file = File.join(ary)
-    raise Puppet::DevError, "No fakedata file #{file}" unless FileTest.exists?(file)
-    file
-  end
-
-  # wrap how to retrieve the masked mode
-  def filemode(file)
-    File.stat(file).mode & 007777
-  end
-
-  def memory
-    Puppet::Util.memory
-  end
-
-  # a list of files that we can parse for testing
-  def textfiles
-    textdir = datadir "snippets"
-    Dir.entries(textdir).reject { |f|
-      f =~ /^\./ or f =~ /fail/
-    }.each { |f|
-      yield File.join(textdir, f)
-    }
-  end
-
-  def failers
-    textdir = datadir "failers"
-    # only parse this one file now
-    files = Dir.entries(textdir).reject { |file|
-      file =~ %r{\.swp}
-    }.reject { |file|
-      file =~ %r{\.disabled}
-    }.collect { |file|
-      File.join(textdir,file)
-    }.find_all { |file|
-      FileTest.file?(file)
-    }.sort.each { |file|
-      Puppet.debug "Processing #{file}"
-      yield file
-    }
-  end
-
-  def mk_catalog(*resources)
-    if resources[0].is_a?(String)
-      name = resources.shift
-    else
-      name = :testing
-    end
-    config = Puppet::Resource::Catalog.new :testing do |conf|
-      resources.each { |resource| conf.add_resource resource }
-    end
-
-    config
-  end
-end