cerberus 0.3.2 → 0.3.3

data/CHANGES

@@ -1,5 +1,31 @@
 = Cerberus Changelog
 
+== Version 0.3.3
+Major changes
+
+* Fix Const load problem with Rails 1.2RC1
+* Correctly implement Jabber publisher using XMPP4R library
+* Upgrade Webgen to 0.4.1
+* Added 'getting better/worse' to build messages' subject
+* Added possibility to configure events on what you would like to receive messages. 
+  By default used 'default' events. It means all except 'successful' state.
+  You could set to this options list of any valid states such as [broken, failed, revival, successful, setup] or predefined sets as
+  [all, default, none].
+
+  You could configure by setting :on_event option to :publisher options branch, or to concrete publisher configuration.
+  In case if this option added both to :publisher and :publisher,<PUBLISHER> then concrete configurations wins.
+
+  Examples of configuration
+
+publisher:
+  on_event: broken, revival
+  mail:
+    on_event: all
+  jabber:
+    #nothing here
+
+  In given example we would send messages about ALL events by mail and only messages about brokeness and revivalness by Jabber.
+
 == Version 0.3.2
 Added Perforce SCM support
 

data/Rakefile

@@ -52,8 +52,8 @@ GEM_SPEC = Gem::Specification.new do |s|
 
   s.add_dependency 'actionmailer', '>= 1.2.5'
   s.add_dependency 'rake', '>= 0.7.1'
-  s.add_dependency 'jabber4r', '>= 0.8.0'
-  s.add_dependency 'Ruby-IRC', '>= 1.0.3'
+  s.add_dependency 'xmpp4r', '>= 0.3'
+  s.add_dependency 'Ruby-IRC', '>= 1.0.7'
 
   s.files = Dir.glob("{bin,lib,test}/**/*").delete_if { |item| item.include?('__workdir') }
   s.files += %w(LICENSE README CHANGES Rakefile)
@@ -143,7 +143,14 @@ task :publish_news do
   end
 end
 
-task :publish_site do
-  system('cd doc/site && webgen')
+require 'webgen/rake/webgentask'
+
+Webgen::Rake::WebgenTask.new do |t|
+  t.directory = File.join(Dir.pwd, "doc/site")
+end
+
+task :publish_site => :webgen do
   sh %{scp -r -q doc/site/output/* #{RUBYFORGE_USER}@rubyforge.org:/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/}
 end
+
+task :release => [:release_files, :publish_news, :webgen]

data/lib/cerberus/builder/bjam.rb

@@ -25,4 +25,8 @@ class Cerberus::Builder::Bjam
    $?.exitstatus == 0 and not @output =~ /failed|error:|skipped/ 
      #/\*\*\* \d+ failure(s)? detected in test suite/ and not @output.include?("syntax error")
  end
+
+ def brokeness
+   return nil
+ end
 end

data/lib/cerberus/builder/maven2.rb

@@ -1,7 +1,7 @@
 require 'cerberus/builder/base'
 
 class Cerberus::Builder::Maven2
-  attr_reader :output
+  attr_reader :output, :brokeness
 
   def initialize(config)
     @config = config
@@ -23,7 +23,9 @@ class Cerberus::Builder::Maven2
   def add_error_information
     str = @output
     @output = ''
+    @brokeness = 0
     while str =~ / <<< FAILURE!$/
+      @brokeness += 1
       s = $'
 
       $` =~ /^(.|\n)*Running (.*)$/

data/lib/cerberus/builder/ruby_base.rb

@@ -19,6 +19,12 @@ class Cerberus::Builder::RubyBase
     $?.exitstatus == 0 and not @output.include?("#{@cmd} aborted!")
   end
 
+  def brokeness
+    if @output =~ /\d+ tests, \d+ assertions, (\d+) failures, (\d+) errors/
+      $1.to_i + $2.to_i
+    end
+  end
+
   private
   def choose_exec
     ext = ['']

data/lib/cerberus/cli.rb

@@ -56,7 +56,7 @@ module Cerberus
   end
 
   HELP = %{
-    Cerberus is a simple Continuous Integration tool for Ruby projects that run from command-line interface.
+    Cerberus is a lightweight command-line Continuous Integration tool for Ruby.
 
     Usage:
       cerberus add <URL>     --- add project from svn repository to list watched of applications

data/lib/cerberus/component_lazy_loader.rb

@@ -0,0 +1,63 @@
+module Cerberus
+  module SCM
+    TYPES = {
+      :svn => 'SVN', #Cerberus::SCM
+      :darcs => 'Darcs',
+      :perforce => 'Perforce'
+    }
+
+    def self.get(type)
+       class_name = TYPES[type.to_sym]
+       say "SCM #{type} not supported" unless class_name
+       require "cerberus/scm/#{type}"
+       const_get(class_name)
+    end
+
+
+    def self.guess_type(path)
+      return nil unless test(?d, path)
+
+      case
+      when test(?d, path+'/.svn')
+        'svn'
+      when test(?d, path+'/_darcs')
+        'darcs'
+      when test(?d, path+'/.cvs')
+        'cvs'
+      end
+    end
+  end
+
+  module Publisher
+    TYPES = {
+      :mail => 'Mail', #Cerberus::Publisher
+      :jabber => 'Jabber',
+      :irc => 'IRC',
+      :rss => 'RSS',
+      :campfire => 'Campfire'
+    }
+
+    def self.get(type)
+       class_name = TYPES[type.to_sym]
+       say "Publisher #{type} not supported" unless class_name
+       require "cerberus/publisher/#{type}"
+       const_get(class_name)
+    end
+  end
+
+  module Builder
+    TYPES = {
+      :maven2 => 'Maven2', #Cerberus::Builder
+      :rake => 'Rake',
+      :rant => 'Rant',
+      :bjam => 'Bjam'
+    }
+
+    def self.get(type)
+       class_name = TYPES[type.to_sym]
+       say "Builder #{type} not supported" unless class_name
+       require "cerberus/builder/#{type}"
+       const_get(class_name)
+    end
+  end
+end

data/lib/cerberus/config.example.yml

@@ -8,10 +8,8 @@ publisher:
     user_name: someuser
     password: somepassword
 #  jabber:
-#    jid: cerberus@gtalk.google.com
-#    port: 5222
-#    password: mypass
-#    digest: false
+#    jid: somemailbox@gmail.com/cerberus
+#    password: somepassword
 #  irc:
 #    nick: cerb
 #    server: irc.freenode.net

data/lib/cerberus/constants.rb

@@ -4,5 +4,5 @@ module Cerberus
 
   LOCK_WAIT = 30 * 60 #30 minutes
 
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end

data/lib/cerberus/latch.rb

@@ -8,7 +8,7 @@ module Cerberus
         modif_time = File::Stat.new(lock_file).mtime
         ttl = options[:lock_ttl]
 
-        if ttl and modif_time < ttl.ago
+        if ttl and modif_time + ttl < Time.now
           File.delete(lock_file)
         else
           return

data/lib/cerberus/manager.rb

@@ -4,6 +4,7 @@ require 'cerberus/utils'
 require 'cerberus/constants'
 require 'cerberus/config'
 require 'cerberus/latch'
+require 'cerberus/component_lazy_loader'
 
 module Cerberus
   class AddCommand
@@ -15,7 +16,7 @@ module Cerberus
     end
 
     def run
-      scm_type = @cli_options[:scm] || 'svn'
+      scm_type = @cli_options[:scm] || Cerberus::SCM.guess_type(@path) || 'svn'
       scm = Cerberus::SCM.get(scm_type).new(@path, Config.new(nil, @cli_options))
       say "Can't find any #{scm_type} application under #{@path}" unless scm.url
 
@@ -67,7 +68,7 @@ module Cerberus
       @config = Config.new(application_name, cli_options.merge(def_options))
       @config.merge!(DEFAULT_CONFIG, false)
 
-      @status = Status.new("#{app_root}/status.log")
+      @status = Status.read("#{app_root}/status.log")
 
       scm_type = @config[:scm, :type]
       @scm = SCM.get(scm_type).new(@config[:application_root], @config)
@@ -80,48 +81,47 @@ module Cerberus
     def run
       begin
         Latch.lock("#{HOME}/work/#{@config[:application_name]}/.lock", :lock_ttl => 2 * LOCK_WAIT) do
-          previous_status = @status.recall
           @scm.update!
 
-          state = 
-          if @scm.has_changes? or @config[:force] or not previous_status
-            if status = @builder.run
-              @status.keep(:succesful)
-              case previous_status
-              when :failed
-                :revival
-              when :succesful
-                :succesful
-              when false
-                :setup
-              end
-            else
-              @status.keep(:failed)
-              previous_status == :failed ? :broken : :failure
-            end
-          else
-            :unchanged
-          end
+          if @scm.has_changes? or @config[:force] or @status.previous_build_successful.nil?
+            build_successful = @builder.run
+            @status.keep(build_successful, @scm.current_revision, @builder.brokeness)
 
-          #Save logs to directory
-          if @config[:log, :enable] and state != :unchanged
-            log_dir = "#{HOME}/work/#{@config[:application_name]}/logs/"
-            FileUtils.mkpath(log_dir)
+            #Save logs to directory
+            if @config[:log, :enable]
+              log_dir = "#{HOME}/work/#{@config[:application_name]}/logs/"
+              FileUtils.mkpath(log_dir)
 
-            time = Time.now.strftime("%Y%m%d%H%M%S")
-            file_name = "#{log_dir}/#{time}-#{state.to_s}.log"
-            body = [ scm.last_commit_message, builder.output ].join("\n\n")
-            IO.write(file_name, body)
-          end
+              time = Time.now.strftime("%Y%m%d%H%M%S")
+              file_name = "#{log_dir}/#{time}-#{@status.current_state.to_s}.log"
+              body = [ scm.last_commit_message, builder.output ].join("\n\n")
+              IO.write(file_name, body)
+            end
 
-          #send notifications
-          if [:failure, :broken, :revival, :setup].include?(state)
+            #send notifications
             active_publishers = get_configuration_option(@config[:publisher], :active, 'mail')
             active_publishers.split(/\W+/).each do |pub|
-              raise "Publisher have no configuration: #{pub}" unless @config[:publisher, pub]
-              Publisher.get(pub).publish(state, self, @config)
+
+              publisher_config = @config[:publisher, pub]
+              raise "Publisher have no configuration: #{pub}" unless publisher_config
+
+              on_event = publisher_config[:on_event] || @config[:publisher, :on_event] || 'default'
+              events = 
+              case on_event
+              when 'all'
+                [:setup, :successful, :revival, :broken, :failed]
+              when 'none'
+                []
+              when 'default'
+                [:setup, :revival, :broken, :failed] #the same as 'all' except successful
+              else
+                on_event.scan(/\w+/).map{|s| s.to_sym}
+              end
+
+              Publisher.get(pub).publish(@status, self, @config) if events.include?(@status.current_state)
             end
           end
+
         end #lock
       rescue Exception => e
         if ENV['CERBERUS_ENV'] == 'TEST'
@@ -129,7 +129,7 @@ module Cerberus
         else
           File.open("#{HOME}/error.log", File::WRONLY|File::APPEND|File::CREAT) do |f| 
             f.puts Time.now.strftime("%a, %d %b %Y %H:%M:%S [#{@config[:application_name]}] --  #{e.class}")
-            f.puts e.message unless e.message.blank?
+            f.puts e.message unless e.message.empty?
             f.puts e.backtrace.collect{|line| ' '*5 + line}
             f.puts "\n"
           end
@@ -173,7 +173,7 @@ module Cerberus
   end
 
   class ListCommand
-    def initialize(cli_options = {})
+    def initialize(cli_options = {})                                                                             
     end
 
     def run
@@ -194,69 +194,84 @@ module Cerberus
     end
   end
 
+  #Fields that are contained in status file
+  # successful (true mean previous build was successful, otherwise - false)
+  # timestamp
+  # revision
+  # brokeness
+  # successful_build_timestamp
+  # successful_build_revision
   class Status
-    def initialize(path)
-      @path = path
-    end
-    
-    def keep(status)
-      File.open(@path, "w+", 0777) { |file| file.write(status.to_s) }
-    end
-    
-    def recall
-      return false unless File.exists?(@path)
-      value = File.read(@path)
-      value.empty? ? false : value.to_sym
+    attr_reader :previous_build_successful, :previous_brokeness, :current_build_successful, :current_brokeness
+
+    def initialize(param)
+      if param.is_a? Hash
+        @hash = param
+        @current_build_successful = @hash['state']
+        @already_kept = true
+      else
+        @path = param
+        value = File.exists?(@path) ? YAML.load(IO.read(@path)) : nil
+
+        @hash =
+        case value
+          when String
+            value = %w(succesful successful setup).include?(value) #fix typo in status values
+            {'successful' => value}
+          when nil
+            {}
+          else
+            #TODO remove it before 0.3.3 release
+            if state = value['state']
+              value['successful'] = %w(succesful successful setup).include?(state)
+            end
+
+            value
+        end
+
+        @already_kept = false
+      end
+
+      @previous_build_successful = @hash['successful']
+      @previous_brokeness = @hash['brokeness']
     end
-  end
-end
 
-module Cerberus
-  module SCM
-    TYPES = {
-      :svn => 'SVN', #Cerberus::SCM
-      :darcs => 'Darcs',
-      :perforce => 'Perforce'
-    }
-
-    def self.get(type)
-       class_name = TYPES[type.to_sym]
-       say "SCM #{type} not supported" unless class_name
-       require "cerberus/scm/#{type}"
-       const_get(class_name)
+    def self.read(file_name)
+      Status.new(file_name)
     end
-  end
 
-  module Publisher
-    TYPES = {
-      :mail => 'Mail', #Cerberus::Publisher
-      :jabber => 'Jabber',
-      :irc => 'IRC',
-      :rss => 'RSS',
-      :campfire => 'Campfire'
-    }
-
-    def self.get(type)
-       class_name = TYPES[type.to_sym]
-       say "Publisher #{type} not supported" unless class_name
-       require "cerberus/publisher/#{type}"
-       const_get(class_name)
+    def keep(build_successful, revision, brokeness)
+      raise 'Status could be kept only once. Please try to reread status file.' if @already_kept
+
+      @current_brokeness = brokeness
+      @current_build_successful = build_successful
+
+      hash = {'successful' => @current_build_successful, 'timestamp' => Time.now, 'revision' => revision, 'brokeness' => brokeness}
+      if build_successful
+        hash['successful_build_timestamp'] = Time.now
+        hash['successful_build_revision'] = revision
+      else
+        hash['successful_build_timestamp'] = @hash['successful_build_timestamp']
+        hash['successful_build_revision'] = @hash['successful_build_revision']
+      end
+
+      File.open(@path, "w+", 0777) { |file| file.write(YAML.dump(hash)) }
+
+      @already_kept = true
     end
-  end
 
-  module Builder
-    TYPES = {
-      :maven2 => 'Maven2', #Cerberus::Builder
-      :rake => 'Rake',
-      :rant => 'Rant',
-      :bjam => 'Bjam'
-    }
-
-    def self.get(type)
-       class_name = TYPES[type.to_sym]
-       say "Builder #{type} not supported" unless class_name
-       require "cerberus/builder/#{type}"
-       const_get(class_name)
+    def current_state
+      raise "Invalid project state. Before calculating status please do keeping of it." unless @already_kept
+
+      if @current_build_successful
+        if @previous_build_successful.nil?
+          :setup
+        else
+          @previous_build_successful ? :successful : :revival
+        end
+      else
+        @previous_build_successful ? :failed : :broken
+      end
     end
   end
-end
+end

data/lib/cerberus/publisher/base.rb

@@ -5,17 +5,31 @@ module Cerberus
     class Base
       def self.formatted_message(state, manager, options)
         subject = 
-        case state
+        case state.current_state
         when :setup
           "Cerberus set up for project (##{manager.scm.current_revision})"
         when :broken
-          "Build still broken (##{manager.scm.current_revision})"
-        when :failure
+          additional_message = nil
+          if state.previous_brokeness and state.current_brokeness
+            additional_message =
+            case
+              when state.previous_brokeness > state.current_brokeness
+                ' but getting better'
+              when state.previous_brokeness < state.current_brokeness
+                ' and getting worse'
+            end
+          end
+          "Build still broken#{additional_message} (##{manager.scm.current_revision})"
+
+        #FIXME instead of using last author as person that broken build try to guess it. I.e. only if one author since last commit did commit - then he broken it.
+        when :failed
           "Build broken by #{manager.scm.last_author} (##{manager.scm.current_revision})"
         when :revival
           "Build fixed by #{manager.scm.last_author} (##{manager.scm.current_revision})"
-        else
-          raise "Unknown build state #{state}"
+        when :revival
+          "Build was successfully built (##{manager.scm.current_revision})"
+        else                              
+          raise "Unknown build state '#{state.current_state.to_s}'"
         end
 
         subject = "[#{options[:application_name]}] #{subject}"

data/lib/cerberus/publisher/irc.rb

@@ -3,6 +3,8 @@ require 'IRC'
 require 'cerberus/publisher/base'
 
 class Cerberus::Publisher::IRC < Cerberus::Publisher::Base
+  class << self; include Cerberus::Utils end
+
   def self.publish(state, manager, options)
     irc_options = options[:publisher, :irc]
     raise "There is no channel provided for IRC publisher" unless irc_options[:channel]
@@ -21,11 +23,7 @@ class Cerberus::Publisher::IRC < Cerberus::Publisher::Base
         }
         bot.send_quit
       }
-      begin
-        bot.connect #Why it always fails?
-      rescue Exception => e
-        puts e.message
-      end
+      bot.connect
     }
   end
 end

data/lib/cerberus/publisher/jabber.rb

@@ -1,5 +1,5 @@
 require 'rubygems'
-require 'jabber4r/jabber4r'
+require 'xmpp4r'
 require 'cerberus/publisher/base'
 
 class Cerberus::Publisher::Jabber < Cerberus::Publisher::Base
@@ -10,26 +10,16 @@ class Cerberus::Publisher::Jabber < Cerberus::Publisher::Base
 
       subject,body = Cerberus::Publisher::Base.formatted_message(state, manager, options)
 
-      session = login(jabber_options[:jid], jabber_options[:password])
+      client = Jabber::Client::new(Jabber::JID.new(jabber_options[:jid]))
+      client.connect
+      client.auth(jabber_options[:password])
+
       jabber_options[:recipients].split(',').each do |address|
-        session.new_message(address.strip).set_subject(subject).set_body(body).send
+        message = Jabber::Message::new(address.strip, body).set_subject(subject)
+        client.send(message)
       end
     ensure
-      session.release if session
-    end
-  end
-
-  def self.login(id_resource, password, register_if_login_fails=true)
-    begin
-      session = ::Jabber::Session.bind(id_resource, password)
-    rescue
-      if(register_if_login_fails)
-        if(::Jabber::Session.register(id_resource, password))
-          Cerberus::Publisher::Jabber.login(id_resource, password, false)
-        else
-          raise "Failed to register #{id_resource}"
-        end
-      end
+      client.close if client
     end
   end
 end

data/test/functional_test.rb

@@ -62,40 +62,49 @@ class FunctionalTest < Test::Unit::TestCase
 
     status_file = HOME + '/work/myapp/status.log'
     assert File.exists?(status_file)
-    assert_equal 'succesful', IO.read(status_file)
-    assert 1, Dir[HOME + "/work/rake_cust/logs/*-succesful.log"].size
+    assert build_successful?(status_file)
+    assert 1, Dir[HOME + "/work/rake_cust/logs/*-setup.log"].size
 
     FileUtils.rm status_file
     build = Cerberus::BuildCommand.new('myapp')
     build.run
     assert File.exists?(status_file)
+    assert build_successful?(status_file)
+    assert_equal :setup, build.status.current_state
     assert_equal 2, ActionMailer::Base.deliveries.size #first email that project was setup
     assert 2, Dir[HOME + "/work/rake_cust/logs/*.log"].size
 
-    build = Cerberus::BuildCommand.new('myapp')
+    build = Cerberus::BuildCommand.new('myapp', :force => true)
     build.run
+    assert_equal :successful, build.status.current_state
     assert_equal 2, ActionMailer::Base.deliveries.size #Number of mails not changed
     assert 2, Dir[HOME + "/work/rake_cust/logs/*.log"].size #even if sources unchanged
 
     #remove status file to run project again
     FileUtils.rm status_file
-    add_test_case_to_project('myapp', 'assert false') { #if assertion failed
-      build = Cerberus::BuildCommand.new('myapp')
-      build.run
-
-      assert_equal 'failed', IO.read(status_file)
-    }
+    add_test_case_to_project('myapp', 'assert false') #if assertion failed
+    build = Cerberus::BuildCommand.new('myapp')
+    build.run
+    assert !build_successful?(status_file)
+    assert_equal :broken, build.status.current_state
     assert_equal 3, ActionMailer::Base.deliveries.size #We should receive mail if project fails
 
 
+    add_test_case_to_project('myapp', 'raise "Some exception here"') #if we have exception
+    build = Cerberus::BuildCommand.new('myapp', :force => true)
+    build.run
+    assert !build_successful?(status_file)
+    assert_equal :broken, build.status.current_state
+  
+    subject = ActionMailer::Base.deliveries.last.subject
+    assert_match /and getting worse/, subject
+
     #remove status file to run project again
     FileUtils.rm status_file
-    add_test_case_to_project('myapp', 'raise "Some exception here"') { #if we have exception
-      build = Cerberus::BuildCommand.new('myapp')
-      build.run
-
-      assert_equal 'failed', IO.read(status_file)
-    }
+    build = Cerberus::BuildCommand.new('myapp')
+    build.run
+    assert !build_successful?(status_file)
+    assert_equal :broken, build.status.current_state
   end
 
   def test_have_no_awkward_header
@@ -108,6 +117,19 @@ class FunctionalTest < Test::Unit::TestCase
     assert_equal 0, build.scm.last_commit_message.index('-' * 72)
   end
 
+  def test_send_on_different_events
+    add_application('myapp', SVN_URL, 'publisher' => {'mail' => {'on_event' => 'none'}, 'on_event' => 'all'})
+    build = Cerberus::BuildCommand.new('myapp')
+    build.run
+    assert_equal 0, ActionMailer::Base.deliveries.size
+
+
+    add_application('myapp', SVN_URL, 'publisher' => {'mail' => {'on_event' => 'all'}, 'on_event' => 'none'})
+    build = Cerberus::BuildCommand.new('myapp')
+    build.run
+    assert_equal 1, ActionMailer::Base.deliveries.size
+  end
+
   def test_multiply_publishers_without_configuration
     add_application('myapp', SVN_URL, 'publisher' => {'active' => 'mail ,  jabber , irc,    dddd'})
 
@@ -148,7 +170,7 @@ class FunctionalTest < Test::Unit::TestCase
     for i in 1..4 do
       status_file = HOME + "/work/myapp#{i}/status.log"
       assert File.exists?(status_file)
-      assert_equal 'succesful', IO.read(status_file)
+      assert build_successful?(status_file)
     end
   end
 
@@ -187,7 +209,7 @@ class FunctionalTest < Test::Unit::TestCase
 
     status_file = HOME + '/work/darcsapp/status.log'
     assert File.exists?(status_file)
-    assert_equal 'succesful', IO.read(status_file)
+    assert build_successful?(status_file)
     assert 1, Dir[HOME + "/work/darcsapp/logs/*.log"].size
 
     #There were no changes - no reaction should be
@@ -244,4 +266,22 @@ class FunctionalTest < Test::Unit::TestCase
 
     assert_equal 2, Marshmallow.counter
   end
+
+  def test_correct_migration_from_previous_status
+    status_fn = TEMP_DIR + '/test_status_file.log'
+
+    status = Cerberus::Status.new(status_fn)
+    assert_equal nil, status.previous_build_successful
+    assert_equal nil, status.current_build_successful
+    
+    IO.write(status_fn, 'failed')
+    status = Cerberus::Status.new(status_fn)
+    assert_equal nil, status.current_build_successful
+    assert_equal false, status.previous_build_successful
+
+    status.keep(true, 1232, 0)
+    assert_equal true, status.current_build_successful
+    assert_equal false, status.previous_build_successful
+    assert_equal :revival, status.current_state
+  end
 end

data/test/integration_test.rb

@@ -48,7 +48,7 @@ class IntegrationTest < Test::Unit::TestCase
 
     run_cerb("build svn_repo")
     assert File.exists?(HOME + '/work/svn_repo/status.log')
-    assert_equal 'succesful', IO.read(HOME + '/work/svn_repo/status.log')
+    assert build_successful?(HOME + '/work/svn_repo/status.log')
   end
 
   def test_add_darcs_scm

data/test/irc_publisher_test.rb

@@ -10,8 +10,9 @@ class IRCPublisherTest < Test::Unit::TestCase
     options = Cerberus::Config.new(nil, :publisher => {:irc => {:channel => 'hello'}}, :application_name => 'IrcApp')
     build = DummyManager.new('last message', 'this is output', 1232, 'anatol')
 
-    Cerberus::Publisher::IRC.publish(:setup, build, options)
+    Cerberus::Publisher::IRC.publish(build_status(true), build, options)
 
     assert IRCConnection.connected
+#    assert_equal 1, IRCConnection.messages.size
   end
 end

data/test/jabber_publisher_test.rb

@@ -1,20 +1,21 @@
 require File.dirname(__FILE__) + '/test_helper'
 
 require 'cerberus/publisher/jabber'
-require 'mock/jabber4r'
+require 'mock/xmpp4r'
 require 'mock/manager'
 
 class JabberPublisherTest < Test::Unit::TestCase
   def test_publisher
-    options = Cerberus::Config.new(nil, :publisher => {:jabber => {:recipients => ' jit1@google.com, another@google.com '}}, :application_name => 'MegaApp')
+    options = Cerberus::Config.new(nil, :publisher => {:jabber => {:jid=>'from.cerberus@gmail.com', :recipients => ' jit1@google.com, another@google.com '}}, :application_name => 'MegaApp')
     build = DummyManager.new('last message', 'this is output', 1232, 'anatol')
 
-    Cerberus::Publisher::Jabber.publish(:setup, build, options)
+    Cerberus::Publisher::Jabber.publish(build_status(false), build, options)
 
-    messages = Jabber::Protocol::Message.messages
-    assert_equal 2, messages.size
-    assert_equal 'google.com', messages[0].to.host
+    messages = Jabber::Client.messages
+    assert messages.size > 2
+    assert_equal 'google.com', messages[0].to.domain
     assert_equal 'jit1', messages[0].to.node
-    assert_equal '[MegaApp] Cerberus set up for project (#1232)', messages[0].subject
+    assert_equal '[MegaApp] Build still broken (#1232)', messages[0].subject
+    assert !messages[0].body.nil?
   end
 end

data/test/mail_publisher_test.rb

@@ -14,7 +14,7 @@ class MailPublisherTest < Test::Unit::TestCase
        :application_name => 'MyApp')
     build = DummyManager.new('last message', 'this is output', 1232, 'anatol')
 
-    Cerberus::Publisher::Mail.publish(:setup, build, options)
+    Cerberus::Publisher::Mail.publish(build_status(true), build, options)
 
     mails = ActionMailer::Base.deliveries
     assert_equal 1, mails.size

data/test/mock/irc.rb

@@ -14,7 +14,7 @@ class IRCConnection
     @@messages << msg
   end
 
-  def self.handle_connection(server, port)
+  def self.handle_connection(server, port, nick, realname)
     @@connected = true
   end
 end

data/test/mock/xmpp4r.rb

@@ -0,0 +1,19 @@
+require 'xmpp4r'
+
+class Jabber::Client
+  @@messages = []
+
+  def connect
+  end
+
+  def send(message)
+    @@messages << message
+  end
+
+  def self.messages
+    @@messages
+  end
+
+  def auth(pwd)
+  end
+end

data/test/rss_publisher_test.rb

@@ -10,11 +10,11 @@ class RSSPublisherTest < Test::Unit::TestCase
     options = Cerberus::Config.new(nil, :publisher => {:rss => {:file => rss_file.path}}, :application_name => 'RSS<App')
     build = DummyManager.new('last message', 'this is output', 1235, 'anatol')
 
-    Cerberus::Publisher::RSS.publish(:setup, build, options)
+    Cerberus::Publisher::RSS.publish(build_status(false), build, options)
 
     xml = REXML::Document.new(IO.read(rss_file.path))
 
-    assert_equal '[RSS<App] Cerberus set up for project (#1235)', xml.elements["rss/channel/item/title/"].get_text.value
+    assert_equal '[RSS<App] Build still broken (#1235)', xml.elements["rss/channel/item/title/"].get_text.value
     assert_match %r{<pre>last message\nthis is output\n--\nCerberus 0.\d.\d, http://cerberus.rubyforge.org/</pre>}, 
                      xml.elements["rss/channel/item/description/"].get_text.value
   end

data/test/test_helper.rb

@@ -1,4 +1,5 @@
 $:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+$:.unshift File.expand_path(File.dirname(__FILE__))
 
 require 'test/unit'
 require 'fileutils'
@@ -57,9 +58,10 @@ class A#{rand(10000)}Test < Test::Unit::TestCase
 end"
     }
 
-    yield
-
-    FileUtils.rm test_case_name
+    if block_given?
+      yield
+      FileUtils.rm test_case_name
+    end
   end
 
   def add_application(app_name, url, options = {})
@@ -71,6 +73,8 @@ end"
     opt.deep_merge!(options)
 
     dump_yml(HOME + "/config/#{app_name}.yml", opt)
+
+    FileUtils.rm_rf HOME + "/work/#{app_name}"
   end
 
   def add_config(options)
@@ -88,6 +92,16 @@ end"
     # Create the new method
     klass.send(:define_method, method_name, block)
   end
+
+  def build_successful?(file_name)
+    data = YAML.load(IO.read(file_name))
+    assert_kind_of Hash, data
+    data['successful']
+  end
+
+  def build_status(successful)
+    Cerberus::Status.new('state' => successful)
+  end
 end
 
 require 'cerberus/config'

metadata

@@ -1,10 +1,10 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.9.0.4
+rubygems_version: 0.9.0.8
 specification_version: 1
 name: cerberus
 version: !ruby/object:Gem::Version 
-  version: 0.3.2
-date: 2006-12-04 00:00:00 +03:00
+  version: 0.3.3
+date: 2007-01-25 00:00:00 +03:00
 summary: Cerberus is a Continuous Integration tool that could be easily run from Cron.
 require_paths: 
 - lib
@@ -33,6 +33,7 @@ files:
 - lib/cerberus
 - lib/cerberus/builder
 - lib/cerberus/cli.rb
+- lib/cerberus/component_lazy_loader.rb
 - lib/cerberus/config.example.yml
 - lib/cerberus/config.rb
 - lib/cerberus/config_migration.rb
@@ -77,9 +78,9 @@ files:
 - test/data/darcs.zip
 - test/data/subversion.dump
 - test/mock/irc.rb
-- test/mock/jabber4r.rb
 - test/mock/manager.rb
 - test/mock/marshmallow.rb
+- test/mock/xmpp4r.rb
 - LICENSE
 - README
 - CHANGES
@@ -117,13 +118,13 @@ dependencies:
         version: 0.7.1
     version: 
 - !ruby/object:Gem::Dependency 
-  name: jabber4r
+  name: xmpp4r
   version_requirement: 
   version_requirements: !ruby/object:Gem::Version::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 0.8.0
+        version: "0.3"
     version: 
 - !ruby/object:Gem::Dependency 
   name: Ruby-IRC
@@ -132,5 +133,5 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.3
+        version: 1.0.7
     version: 

data/test/mock/jabber4r.rb

@@ -1,24 +0,0 @@
-class Jabber::Session
-  def self.bind(jid, password)
-    Jabber::Session.new
-  end
-
-  def initialize
-  end
-end
-
-class Jabber::Protocol::Message
-  @@messages = []
-
-  def self.messages
-    @@messages
-  end
-
-  def self.clear
-    @@messages = []
-  end
-
-  def send
-    @@messages << self
-  end
-end