Refactoring reporting. Reports are now modules instead of simple methods.

git-svn-id: https://reductivelabs.com/svn/puppet/trunk@1746 980ebf18-57e1-0310-9a29-db15c13687c0

1 files changed, 105 insertions, 69 deletions

diff --git a/test/server/report.rb b/test/server/report.rb
index f5f1c1412..f056de0b6 100755
--- a/test/server/report.rb
+++ b/test/server/report.rb
@@ -2,9 +2,13 @@ require 'puppet'
 require 'puppet/server/report'
 require 'puppet/client/reporter'
 require 'puppettest'
+require 'puppettest/reporttesting'
 
 class TestReportServer < Test::Unit::TestCase
 	include PuppetTest
+	include PuppetTest::Reporttesting
+
+    Report = Puppet::Server::Report
 	Puppet::Util.logmethods(self)
 
     def mkserver
@@ -25,62 +29,6 @@ class TestReportServer < Test::Unit::TestCase
         client
     end
 
-    def test_report
-        # Create a bunch of log messages in an array.
-        report = Puppet::Transaction::Report.new
-
-        10.times { |i|
-            log = warning("Report test message %s" % i)
-            log.tags = %w{a list of tags}
-            log.tags << "tag%s" % i
-
-            report.newlog(log)
-        }
-
-        # Now make our reporting client
-        client = mkclient()
-
-        # Now send the report
-        file = nil
-        assert_nothing_raised("Reporting failed") {
-            file = client.report(report)
-        }
-
-        # And make sure our YAML file exists.
-        assert(FileTest.exists?(file),
-            "Report file did not get created")
-
-        # And then try to reconstitute the report.
-        newreport = nil
-        assert_nothing_raised("Failed to load report file") {
-            newreport = YAML.load(File.read(file))
-        }
-
-        # Make sure our report is valid and stuff.
-        report.logs.zip(newreport.logs).each do |ol,nl|
-            %w{level message time tags source}.each do |method|
-                assert_equal(ol.send(method).to_s, nl.send(method).to_s,
-                    "%s got changed" % method)
-            end
-        end
-    end
-
-    # Make sure we don't have problems with calling mkclientdir multiple
-    # times.
-    def test_multiple_clients
-        server ||= mkserver()
-
-        %w{hostA hostB hostC}.each do |host|
-            dir = tempfile()
-            assert_nothing_raised("Could not create multiple host report dirs") {
-                server.send(:mkclientdir, host, dir)
-            }
-
-            assert(FileTest.directory?(dir),
-                "Directory was not created")
-        end
-    end
-
     def test_report_autoloading
         # Create a fake report
         fakedir = tempfile()
@@ -93,9 +41,11 @@ class TestReportServer < Test::Unit::TestCase
         $myreportrun = false
         file = File.join(libdir, "myreport.rb")
         File.open(file, "w") { |f| f.puts %{
-                Puppet::Server::Report.newreport(:myreport) do |report|
-                    $myreportrun = true
-                    return report
+                Puppet::Server::Report.newreport(:myreport) do
+                    def process(report)
+                        $myreportrun = true
+                        return report
+                    end
                 end
             }
         }
@@ -104,30 +54,79 @@ class TestReportServer < Test::Unit::TestCase
         # Create a server
         server = Puppet::Server::Report.new
 
-        method = nil
+        report = nil
         assert_nothing_raised {
-            method = Puppet::Server::Report.reportmethod(:myreport)
+            report = Puppet::Server::Report.report(:myreport)
         }
-        assert(method, "Did not get report method")
+        assert(report, "Did not get report")
+
+    end
 
-        assert(! server.respond_to?(method),
-            "Server already responds to report method")
+    def test_process
+        server = Puppet::Server::Report.new
+
+        # We have to run multiple reports to make sure there's no conflict
+        reports = []
+        $run = []
+        5.times do |i|
+            name = "processtest%s" % i
+            reports << name
+
+            Report.newreport(name) do
+                def process
+                    $run << self.report_name
+                end
+            end
+        end
+        Puppet[:reports] = reports.collect { |r| r.to_s }.join(",")
+
+        report = fakereport
 
         retval = nil
         assert_nothing_raised {
-            retval = server.send(:process, YAML.dump("a string"))
+            retval = server.send(:process, YAML.dump(report))
         }
-        assert($myreportrun, "Did not run report")
-        assert(server.respond_to?(method),
-            "Server does not respond to report method")
+
+        reports.each do |name|
+            assert($run.include?(name.intern), "Did not run %s" % name)
+        end
 
         # Now make sure our server doesn't die on missing reports
         Puppet[:reports] = "fakereport"
         assert_nothing_raised {
-            retval = server.send(:process, YAML.dump("a string"))
+            retval = server.send(:process, YAML.dump(report))
         }
     end
 
+    # Make sure reports can specify whether to use yaml or not
+    def test_useyaml
+        server = Puppet::Server::Report.new
+
+        Report.newreport(:yamlyes, :useyaml => true) do
+            def process(report)
+                $yamlyes = :yesyaml
+            end
+        end
+
+        Report.newreport(:yamlno) do
+            def process
+                $yamlno = :noyaml
+            end
+        end
+
+        Puppet[:reports] = "yamlyes, yamlno"
+
+        report = fakereport
+        yaml = YAML.dump(report)
+
+        assert_nothing_raised do
+            server.send(:process, yaml)
+        end
+
+        assert_equal(:noyaml, $yamlno, "YAML was used for non-yaml report")
+        assert_equal(:yesyaml, $yamlyes, "YAML was not used for yaml report")
+    end
+
     def test_reports
         Puppet[:reports] = "myreport"
 
@@ -141,6 +140,43 @@ class TestReportServer < Test::Unit::TestCase
             assert_equal(ary, server.send(:reports))
         end
     end
+
+    def test_newreport
+        name = :newreporttest
+        assert_nothing_raised do
+            Report.newreport(name) do
+                attr_accessor :processed
+
+                def process(report)
+                    @processed = report
+                end
+            end
+        end
+
+        assert(Report.report(name), "Did not get report")
+        assert_instance_of(Module, Report.report(name))
+
+        obj = "yay"
+        obj.extend(Report.report(name))
+
+        assert_nothing_raised do
+            obj.process("yay")
+        end
+
+        assert_equal("yay", obj.processed)
+    end
+
+    # Make sure we get a list of all reports
+    def test_report_list
+        list = nil
+        assert_nothing_raised do
+            list = Puppet::Server::Report.reports
+        end
+
+        [:rrdgraph, :store, :tagmail].each do |name|
+            assert(list.include?(name), "Did not load %s" % name)
+        end
+    end
 end
 
 # $Id$