puppet 0.25.5 → 2.6.0

data/test/lib/puppettest/railstesting.rb

@@ -1,53 +1,52 @@
 module PuppetTest::RailsTesting
-    Parser = Puppet::Parser
-    AST = Puppet::Parser::AST
-    include PuppetTest::ParserTesting
-
-    def teardown
-        super
-
-        # If we don't clean up the connection list, then the rails
-        # lib will still think it's connected.
-        if Puppet.features.rails?
-            ActiveRecord::Base.clear_active_connections!
-        end
-    end
-
-    def railsinit
-        Puppet::Rails.init
-    end
-
-    def railsteardown
-        if Puppet[:dbadapter] != "sqlite3"
-            Puppet::Rails.teardown
-        end
-    end
-
-    def railsresource(type = "file", title = "/tmp/testing", params = {})
-        railsteardown
-        railsinit
-
-        # We need a host for resources
-        #host = Puppet::Rails::Host.new(:name => Facter.value("hostname"))
-
-        # Now build a resource
-        resources = []
-        resources << mkresource(:type => type, :title => title, :exported => true,
-                   :params => params)
-
-        # Now collect our facts
-        facts = Facter.to_hash
-
-        # Now try storing our crap
-        host = nil
-        node = mknode(facts["hostname"])
-        node.parameters = facts
-        assert_nothing_raised {
-            host = Puppet::Rails::Host.store(node, resources)
-        }
-
-        # Now save the whole thing
-        host.save
-    end
+  Parser = Puppet::Parser
+  AST = Puppet::Parser::AST
+  include PuppetTest::ParserTesting
+
+  def teardown
+    super
+
+    # If we don't clean up the connection list, then the rails
+    # lib will still think it's connected.
+    ActiveRecord::Base.clear_active_connections! if Puppet.features.rails?
+  end
+
+  def railsinit
+    Puppet::Rails.init
+  end
+
+  def railsteardown
+    Puppet::Rails.teardown if Puppet[:dbadapter] != "sqlite3"
+  end
+
+  def railsresource(type = "file", title = "/tmp/testing", params = {})
+    railsteardown
+    railsinit
+
+    # We need a host for resources
+    #host = Puppet::Rails::Host.new(:name => Facter.value("hostname"))
+
+    # Now build a resource
+    resources = []
+
+      resources << mkresource(
+        :type => type, :title => title, :exported => true,
+
+          :parameters => params)
+
+    # Now collect our facts
+    facts = Facter.to_hash
+
+    # Now try storing our crap
+    host = nil
+    node = mknode(facts["hostname"])
+    node.parameters = facts
+    assert_nothing_raised {
+      host = Puppet::Rails::Host.store(node, resources)
+    }
+
+    # Now save the whole thing
+    host.save
+  end
 end
 

data/test/lib/puppettest/reporttesting.rb

@@ -1,16 +1,16 @@
 module PuppetTest::Reporttesting
-    def fakereport
-        # Create a bunch of log messages in an array.
-        report = Puppet::Transaction::Report.new
+  def fakereport
+    # Create a bunch of log messages in an array.
+    report = Puppet::Transaction::Report.new
 
-        3.times { |i|
-            # We have to use warning so that the logs always happen
-            log = Puppet.warning("Report test message %s" % i)
+    3.times { |i|
+      # We have to use warning so that the logs always happen
+      log = Puppet.warning("Report test message #{i}")
 
-            report.newlog(log)
-        }
+      report << log
+    }
 
-        return report
-    end
+    report
+  end
 end
 

data/test/lib/puppettest/resourcetesting.rb

@@ -1,45 +1,54 @@
 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"))
-        )
+  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
 
-    def mkresource(args = {})
-        args[:source] ||= "source"
-        args[:scope] ||= mkscope
-
-        {:type => "resource", :title => "testing",
-            :source => "source", :scope => "scope"}.each do |param, value|
-                args[param] ||= value
-        end
-
-        params = args[:params] || {:one => "yay", :three => "rah"}
-        if args[:params] == :none
-            args.delete(:params)
-        else
-            args[:params] = paramify args[:source], params
-        end
-
-        Parser::Resource.new(args)
+    params = args[:parameters] || {:one => "yay", :three => "rah"}
+    if args[:parameters] == :none
+      args.delete(:parameters)
+    else
+      args[:parameters] = paramify args[:source], params
     end
 
-    def param(name, value, source)
-        Parser::Resource::Param.new(:name => name, :value => value, :source => source)
-    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
+  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,35 +1,43 @@
 # Manage whether a test is runnable.
 module PuppetTest
-    module RunnableTest
-        # Confine this test based on specified criteria.  The keys of the
-        # hash should be the message to use if the test is not suitable,
-        # and the values should be either 'true' or 'false'; true values
-        # mean the test is suitable.
-        def confine(hash)
-            @confines ||= {}
-            hash.each do |message, result|
-                @confines[message] = result
-            end
-        end
+  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
 
-        attr_reader :messages
+    # 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?
 
-        # Evaluate all of our tests to see if any of them are false
-        # and thus whether this test is considered not runnable.
-        def runnable?
-            @messages ||= []
-            if superclass.respond_to?(:runnable?) and ! superclass.runnable?
-                return false
-            end
-            return false unless @messages.empty?
-            return true unless defined? @confines
-            @confines.find_all do |message, result|
-                ! result
-            end.each do |message, result|
-                @messages << message
-            end
+      confines.each do |message, is_runnable|
+        is_runnable = is_runnable.call if is_runnable.respond_to?(:call)
+        messages << message unless is_runnable
+      end
 
-            return @messages.empty?
-        end
+      messages.empty?
     end
+
+    def messages; @messages ||= [] end
+
+    private
+
+    def confines; @confines ||= {} end
+  end
+
 end

data/test/lib/puppettest/servertest.rb

@@ -2,70 +2,73 @@ require 'puppettest'
 require 'puppet/network/http_server/webrick'
 
 module PuppetTest::ServerTest
-    include PuppetTest
-    def setup
-        super
+  include PuppetTest
+  def setup
+    super
 
-        if defined? @@port
-            @@port += 1
-        else
-            @@port = 20000
-        end
+    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], "%ssite.pp" % (self.class.to_s + "test"))
-        #@createdfile = File.join(tmpdir(), self.class.to_s + "manifesttesting" +
-        #    "_" + @method_name)
-        @createdfile = tempfile()
+  # 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
-        }
+    File.open(file, "w") { |f|
+      f.puts "file { \"%s\": ensure => file, mode => 755 }\n" % @createdfile
+    }
 
-        @@tmpfiles << @createdfile
-        @@tmpfiles << file
+    @@tmpfiles << @createdfile
+    @@tmpfiles << file
 
-        return file
+    file
+  end
+
+  # create a server, forked into the background
+  def mkserver(handlers = nil)
+    Puppet[:name] = "puppetmasterd"
+    # our default handlers
+    unless handlers
+      handlers = {
+        :CA => {}, # so that certs autogenerate
+        :Master => {
+          :Manifest => mktestmanifest,
+          :UseNodes => false
+        },
+      }
     end
 
-    # create a server, forked into the background
-    def mkserver(handlers = nil)
-        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 {
 
-        # then create the actual server
-        server = nil
-        assert_nothing_raised {
             server = Puppet::Network::HTTPServer::WEBrick.new(
-                :Port => @@port,
-                :Handlers => handlers
-            )
-        }
+                
+        :Port => @@port,
+        
+        :Handlers => handlers
+      )
+    }
 
-        # fork it
-        spid = fork {
-            trap(:INT) { server.shutdown }
-            server.start
-        }
+    # fork it
+    spid = fork {
+      trap(:INT) { server.shutdown }
+      server.start
+    }
 
-        # and store its pid for killing
-        @@tmppids << spid
+    # and store its pid for killing
+    @@tmppids << spid
 
-        # give the server a chance to do its thing
-        sleep 1
-        return spid
-    end
+    # give the server a chance to do its thing
+    sleep 1
+    spid
+  end
 
 end
 

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

@@ -2,72 +2,65 @@ require 'puppettest'
 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
+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
 
-        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
+  def assert_uid_gid(uid, gid, filename)
+    flunk "Must be uid 0 to run these tests" unless Process.uid == 0
 
-        # avoid a race.
-        true while !File.exists? filename
+    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
 
-        f = File.open(filename, "r")
+    # avoid a race.
+    true while !File.exists? filename
 
-        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
+    f = File.open(filename, "r")
 
-    def assert_rollback_events(trans, events, msg = nil)
-        run_events(:rollback, trans, events, msg)
-    end
+    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
+  def assert_events(events, *resources)
+    trans = nil
+    comp = nil
+    msg = nil
 
-        unless events.is_a? Array
-            raise Puppet::DevError, "Incorrect call of assert_events"
-        end
-        if resources[-1].is_a? String
-            msg = resources.pop
-        end
+    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)
+    config = resources2catalog(*resources)
+    transaction = Puppet::Transaction.new(config)
 
-        run_events(:evaluate, transaction, events, msg)
+    run_events(:evaluate, transaction, events, msg)
 
-        return transaction
-    end
+    transaction
+  end
 
-    # A simpler method that just applies what we have.
-    def assert_apply(*resources)
-        config = resources2catalog(*resources)
+  # 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
+    events = nil
+    assert_nothing_raised("Failed to evaluate") {
+      events = config.apply.events
+    }
+    events
+  end
 end