cerberus 0.1.0

data/CHANGES

@@ -0,0 +1,7 @@
+= Cerberus Changelog
+
+== Version 0.1.0
+
+Initial version of Cerberus tool
+
+* Implemented basic functionality required by Continuous Integration.

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2006 Anatol Pomozov
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/README

@@ -0,0 +1,57 @@
+Cerberus developed by Anatol Pomozov (anatol.pomozov@gmail.com) and shared under MIT license.
+
+Cerberus is continuous integration (CI) software. Cerberus could be periodically run from scheduler 
+and check if application tests are broken. If it happend then Cerberus sends notification to developers.
+
+For more CI theory read this document from Martin Fowler 
+http://www.martinfowler.com/articles/continuousIntegration.html.
+
+Requirements: 
+  ruby - 1.8.2 or higher
+  rake - 0.7 or higher
+  svn client - 1.2 or higher
+
+
+What 'Cerberus' name means?
+Quote from Wikipedia (http://en.wikipedia.org/wiki/Cerberus)
+
+Cerberus or Kerberos (Kerberos, demon of the pit), was the hound of Hades-a monstrous three-headed dog (sometimes said to have 50 or 100 heads) with a snake for a tail and innumerable snake heads on his back.
+He guarded the gate to Hades (the Greek underworld) and ensured that the dead could not leave and the living could not enter. His brother was Orthrus. He is the offspring of Echidna and Typhon.
+
+
+So Cerberus will guard your tests and not allow your project to go to the world of dead.
+
+
+To use Cerberus it is very easy. First install it. Easiest way to do it through RubyGems package manager.
+
+'gem install cerberus'
+
+then you need to add project that will be watched by Cerberus. Do it by
+
+cerberus add (DIR|SVN_URL)?    #Adds project to list of watched applications
+
+as second parameted you could pass URL to subversion repository or directory with working SVN folder.
+If this parameted absent then would be added project from current directory
+
+Go to ~./cerberus and edit config.yml file (only once after installing Cerberus). Enter your configuration options here
+like email server, password, user_name and other options. See ActiveMailer description - Cerberus uses it as notification
+layer. Mine config file looks like this
+mail:
+  address: mail.somesever.com
+  user_name: anatol
+  password: anatol
+  domain: somesever.com
+  authentication: login
+
+Also go to ~/.cerberus/config/<PROJECT_NAME>.yml and add comma-separated list of recipients for this project
+You could also change <PROJECT_NAME> to any other name. This name what Cerberus will use.
+
+And then run Cerberus 
+
+cerberus build PROJECT_NAME    #Run project
+
+It will check out latest sources and run tests for your app. If tests are broken - recipients will recieve notifications.
+
+But of course better run Cerberus automatically from Cron. Run it each 10 minutes for project will be ok.
+
+Well, thats all. If you have any questions, proposals - just let me know.

data/Rakefile

@@ -0,0 +1,129 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+
+require "./lib/cerberus/version"
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'cerberus'
+PKG_VERSION   = Cerberus::VERSION::STRING + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "cerberus"
+RUBY_FORGE_USER    = "anatol"
+
+task :default => [:test, :clean]
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+desc "Clean all generated files"
+task :clean => :clobber_package do
+  rm_rf './test/__workdir'
+end
+
+
+GEM_SPEC = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = ">=1.8.2"
+
+  s.summary = "Cerberus is a Continuous Integration tool that could be easily run from Cron."
+  s.description = <<-DESC.strip.gsub(/\n\s+/, " ")
+    Cerberus is a Continuous Integration software for Ruby projects. CI helps you keep your project 
+    in a good shape.
+
+    For now Cerberus only work with projects that use Subversion but in the future it would be provided
+    support for other VCS.
+
+    Cerberus could be easily invoked from Cron (for Unix) or nnCron (for Windows) utilities.
+  DESC
+
+  s.add_dependency 'actionmailer', '>= 1.2.1'
+  s.add_dependency 'rake', '>= 0.7.1'
+
+  s.files = Dir.glob("{bin,doc,lib,test}/**/*").delete_if { |item| item.include?('__workdir') }
+  s.files += %w(LICENSE README CHANGES Rakefile)
+
+  s.bindir = "bin"
+  s.executables = ["cerberus"]
+  s.default_executable = "cerberus"
+
+  s.require_path = 'lib'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = [ "README" ]
+  s.rdoc_options = [ "--main", "README" ]
+
+  s.test_suite_file = "test/integration_test.rb"
+
+  s.author = "Anatol Pomozov"
+  s.email = "anatol.pomozov@gmail.com"
+  s.homepage = "http://rubyforge.org/projects/cerberus"
+  s.rubyforge_project = "cerberus"
+end
+
+
+Rake::GemPackageTask.new(GEM_SPEC) do |p|
+  p.gem_spec = GEM_SPEC
+  p.need_tar = true
+  p.need_zip = true
+end
+
+task :install => [:clean, :test, :package] do
+  system "gem install pkg/#{PKG_NAME}-#{PKG_VERSION}.gem"
+end
+
+task :uninstall => [:clean] do
+  system "gem uninstall #{PKG_NAME}"
+end
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  Pathname.new(File.dirname(__FILE__)).egrep(/#.*(FIXME|TODO|TBD|DEPRECATED)/) do |match|
+    puts match
+  end
+end
+
+task :reinstall => [:uninstall, :install] do
+end
+
+task :release_files => [:clean, :package] do
+  require 'meta_project'
+  project = MetaProject::Project::XForge::RubyForge.new(RUBY_FORGE_PROJECT)
+
+  release_files = FileList[
+    "pkg/#{PKG_FILE_NAME}.gem",
+    "pkg/#{PKG_FILE_NAME}.zip",
+    "pkg/#{PKG_FILE_NAME}.tgz"
+  ]
+
+  Rake::XForge::Release.new(project) do |release|
+    release.user_name = RUBY_FORGE_USER
+    release.password = ENV['RUBYFORGE_PASSWORD']
+    release.files = release_files.to_a
+    release.package_name    = PKG_NAME
+    release.release_name = "Cerberus #{PKG_VERSION}"
+  end
+
+end
+
+task :publish_news do
+  require 'meta_project'
+  Rake::XForge::NewsPublisher.new(project) do |publisher|
+    publisher.user_name = RUBY_FORGE_USER
+    publisher.password = ENV['RUBYFORGE_PASSWORD']
+    publisher.subject = "Cerberus #{PKG_VERSION} Released"
+    publisher.details = "I am glad to announce first public release of Cerberus tool. Version #{PKG_VERSION} is out. Cerberus is a simple command-line Continuous integration tool for Ruby project. Install Cerberus with 'gem install cerberus' then add project 'cerberus add SVN_URL' and then build it 'cerberus build YOUR_PROJECT_NAME'"
+  end
+end

data/bin/cerberus

@@ -0,0 +1,3 @@
+require 'cerberus/cli'
+
+Cerberus::CLI.new(*ARGV)

data/lib/cerberus/cli.rb

@@ -0,0 +1,68 @@
+require 'cerberus/manager'
+require 'cerberus/utils'
+require 'cerberus/version'
+require 'cerberus/constants'
+
+module Cerberus
+  class CLI     
+    include Cerberus::Utils
+
+    def initialize(*args)
+      say HELP if args.empty?
+
+      command = args.shift
+      say HELP unless %w(add build).include?(command)
+
+      cli_options = extract_options(args)
+
+      case command
+      when 'add'
+        path = args.shift || Dir.pwd
+        
+        command = Cerberus::Add.new(path, cli_options)
+        command.run
+      when 'build'
+        say HELP if args.empty?
+
+        application_name  = args.shift
+
+        command = Cerberus::Build.new(application_name, cli_options)
+        begin
+          command.run
+        rescue Exception => e
+          File.open("#{HOME}/work/#{application_name}/error.log", File::WRONLY|File::APPEND|File::CREAT) do |f| 
+            f.puts Time.now.strftime("%a, %d %b %Y %H:%M:%S %z")
+            f.puts e.message
+            f.puts e.backtrace.collect{|line| ' '*5 + line}
+            f.puts "\n"
+          end
+        end
+      end
+    end
+
+    private 
+    def extract_options(args)
+      result = {}
+      args_copy = args.dup
+      args_copy.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/
+          result[$1.downcase.to_sym] = $2
+          args.delete(arg)
+        end
+      end
+
+      result
+    end
+  end
+
+  HELP = %{
+    Cerberus is a Continuous Integration tool that could be run from commad line.
+
+    Usage:
+      cerberus add <URL>      --- add project from svn repository to list watched of applications
+      cerberus add <PATH>     --- add project from local path to list of watched applications
+      cerberus build <APPLICATION_NAME>  --- build watched application
+
+    Version #{Cerberus::VERSION::STRING}
+  }.gsub("\n    ","\n")
+end

data/lib/cerberus/config.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'active_support'
+
+require 'cerberus/constants'
+
+module Cerberus
+  class Config
+    def initialize(app_name, cli_options = {})
+      @config = HashWithIndifferentAccess.new
+      if app_name
+        @config.merge!(YAML.load(IO.read(CONFIG_FILE))) if test(?f, CONFIG_FILE)
+        @config.merge!(YAML.load(IO.read(HOME + "/config/#{app_name}.yml")))
+      end
+      @config.merge!(cli_options)
+    end
+
+    def [](name)
+      @config[name]
+    end
+
+    private
+    def symbolize_hash(hash)
+      hash.each_pair{|k,v|
+        if v === Hash
+          hash[k] = HashWithIndifferentAccess.new(symbolize_hash(v))
+        end
+      }
+    end
+  end
+end

data/lib/cerberus/constants.rb

@@ -0,0 +1,4 @@
+module Cerberus
+  HOME = File.expand_path(ENV['CERBERUS_HOME'] || '~/.cerberus')
+  CONFIG_FILE = "#{HOME}/config.yml"
+end

data/lib/cerberus/latch.rb

@@ -0,0 +1,22 @@
+module Cerberus
+  module FSLatch
+    #Emulate File.flock
+    def self.lock(lock_file, wait_for_unlock=true)
+      counter = 0
+      while File.exists?(lock_file)
+        return unless wait_for_unlock #if file exists then return
+
+        sleep(10) #sleep for 10 seconds
+        counter += 1
+        raise "Could not wait anymore file unlocking '#{lock_file}'" if counter > 20 #if we are waiting more than 200 secs then raise exception
+      end
+
+      begin
+        File.new(lock_file, 'w')
+        yield
+      ensure
+        File.rm(lockfile)
+      end
+    end
+  end
+end

data/lib/cerberus/manager.rb

@@ -0,0 +1,246 @@
+require 'rubygems'
+require 'action_mailer'
+require 'fileutils'
+
+require 'cerberus/utils'
+require 'cerberus/constants'
+require 'cerberus/config'
+
+module Cerberus
+  class Add
+    include Cerberus::Utils
+
+    def initialize(path, cli_options = {})
+      @path, @config = path, Config.new(nil, cli_options)
+    end
+
+    def run
+      checkout = Checkout.new(@path, @config)
+      say "Can't find any svn application under #{@path}" unless checkout.url
+
+      application_name = @config[:application_name] || File.basename(File.expand_path(@path)).strip
+
+      create_default_config
+      
+      config_name = "#{HOME}/config/#{application_name}.yml"
+      say "Application #{application_name} already present in Cerberus" if File.exists?(config_name)
+
+      app_config = {
+        'url' => checkout.url,
+        'recipients' => @config[:recipients]
+      }
+      dump_yml(config_name, app_config)
+      puts "Application '#{application_name}' was successfully added to Cerberus" unless @config[:quiet]
+    end
+
+    private
+    def create_default_config
+      default_mail_config = 
+        {'mail'=>
+          { 'delivery_method'=>'smtp', 
+            'address'=>'somserver.com', 
+            'port' => 25, 
+            'domain'=>'somserver.com', 
+            'user_name'=>'secret_user', 
+            'password'=>'secret_password',
+            'authentication' => 'plain'
+          }, 
+          'sender' => "'Cerberus' <cerberus@example.com>"}
+      dump_yml(CONFIG_FILE, default_mail_config, false)
+    end
+  end
+
+  class Build
+    include Cerberus::Utils
+    attr_reader :output, :success, :checkout, :status
+
+    def initialize(application_name, cli_options = {})
+      unless File.exists?("#{HOME}/config/#{application_name}.yml")
+        say "Project #{application_name} does not present in Cerberus"
+      end
+
+      app_root = "#{HOME}/work/#{application_name}"
+      
+      def_options = {:application_root => app_root + '/sources', :application_name => application_name} #pseudo options that stored in config. Could not be set in any config file not through CLI
+      @config = Config.new(application_name, cli_options.merge(def_options))
+
+      @status = Status.new("#{app_root}/status.log")
+
+      @checkout = Checkout.new(@config[:application_root], @config)
+    end
+ 
+    def run
+      @checkout.update!
+
+      previous_status = @status.recall
+
+      state = 
+      if @checkout.has_changes? or not previous_status
+        if status = make
+          @status.keep(:succesful)
+          previous_status == :failed ? :revived : :succesful
+        else
+          @status.keep(:failed)
+          previous_status == :failed ? :broken : :failed
+        end
+      else
+        :unchanged
+      end
+
+      case state
+        when :failed
+          Notifier.deliver_failure(self, @config)
+        when :revived
+          Notifier.deliver_revival(self, @config)
+        when :broken
+          Notifier.deliver_broken(self, @config)
+        when :unchanged, :succesful
+          unless previous_status  #If it first time we build application then let everyone to know that we have Cerberus now
+            Notifier.deliver_setup(self, @config)
+          end
+
+          # Smile, be happy, it's all good
+      end
+    end
+ 
+    private
+      def make
+        Dir.chdir @config[:application_root]
+
+        @output = `#{@config[:bin_path]}#{choose_rake_exec()} #{@config[:rake_task]} 2>&1`
+
+        make_successful?
+      end
+      
+      def make_successful?
+         $?.exitstatus == 0 and not @output.include?('rake aborted!')
+      end
+
+      def choose_rake_exec
+        ext = ['']
+
+        if os() == :windows 
+          ext << '.bat' << '.cmd'
+        end
+
+        ext.each{|e|
+          begin
+            out = `rake#{e} --version`
+            return "rake#{e}" if out =~ /rake/
+          rescue
+          end
+        }
+      end
+  end
+  
+  class Checkout
+    def initialize(path, options = {})
+      raise "Path can't be nil" unless path
+
+      @path, @options = path.strip, options
+      @encoded_path = (@path.include?(' ') ? "\"#{@path}\"" : @path)
+    end
+
+    def update!
+      if test(?d, @path + '/.svn')
+        @status = execute("svn update")
+      else
+        FileUtils.mkpath(@path) unless test(?d,@path)
+        @status = execute("svn checkout", nil, @options[:url])
+      end
+    end
+
+    def has_changes?
+      @status =~ /[A-Z]\s+[\w\/]+/
+    end
+
+    def current_revision
+      info['Revision'].to_i
+    end
+ 
+    def url
+      info['URL']
+    end
+ 
+    def last_commit_message
+      message = execute("svn log", "--limit 1 -v")
+      #strip first line that contains command line itself (svn log --limit ...)
+      if ((idx = message.index('-'*72)) != 0 )
+        message[idx..-1]
+      else
+        message
+      end
+    end
+ 
+    def last_author
+      info['Last Changed Author']
+    end
+
+    private
+      def info
+        @info ||= YAML.load(execute("svn info"))
+      end
+      
+      def execute(command, parameters = nil, pre_parameters = nil)
+        `#{@options[:bin_path]}#{command} #{pre_parameters} #{@encoded_path} #{parameters}`
+      end
+  end
+
+  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
+      value = File.exists?(@path) ? File.read(@path) : false
+      value.blank? ? false : value.to_sym
+    end
+  end
+
+  class Notifier < ActionMailer::Base
+    include Cerberus::Utils
+    
+    def failure(build, options)
+      @subject = "Build broken by #{build.checkout.last_author} (##{build.checkout.current_revision})"
+      send_message(build, options)
+    end
+    
+    def broken(build, options)
+      @subject = "Build still broken (##{build.checkout.current_revision})"
+      send_message(build, options)
+    end
+    
+    def revival(build, options)
+      @subject = "Build fixed by #{build.checkout.last_author} (##{build.checkout.current_revision})"
+      send_message(build, options)
+    end
+
+    def setup(build, options)
+      @subject = "Cerberus set up for project (##{build.checkout.current_revision})"
+      send_message(build, options)
+    end
+
+    private
+    def send_message(build, options)
+      mail_config = options[:mail] || {}
+      [:authentication, :delivery_method].each do |k|
+        mail_config[k] = mail_config[k].to_sym if mail_config[k]
+      end
+
+      ActionMailer::Base.delivery_method = mail_config[:delivery_method] if mail_config[:delivery_method]
+      ActionMailer::Base.server_settings = mail_config
+
+      @subject = "[#{options[:application_name]}] " + @subject
+      @body    = [ build.checkout.last_commit_message, build.output ].join("\n\n")
+
+      @recipients, @sent_on = options[:recipients], Time.now
+
+      @from = options[:sender] || "'Cerberus' <cerberus@example.com>"
+      raise "Please specify recipient addresses for application '#{options[:application_name]}'" unless options[:recipients]
+    end
+  end
+end

data/lib/cerberus/utils.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+
+module Cerberus
+  module Utils
+    def say(info)
+      puts info
+      exit 1
+    end
+
+    def os
+      case RUBY_PLATFORM
+      when /mswin/
+        :windows
+      else
+        :unix
+      end
+    end
+
+    def dump_yml(file, what, overwrite = true)
+      if overwrite or not File.exists?(file)
+        FileUtils.mkpath(File.dirname(file))
+        File.open(file, 'w') {|f| YAML::dump(what, f) } 
+      end
+    end
+
+    def load_yml(file_name, default = {})
+      File.exists?(file_name) ? YAML::load(IO.read(file_name)) : default
+    end
+  end
+end

data/lib/cerberus/version.rb

@@ -0,0 +1,9 @@
+module Cerberus
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/test/config_test.rb

@@ -0,0 +1,25 @@
+require 'test_helper'
+require 'cerberus/config'
+
+class ConfigTest < Test::Unit::TestCase
+  def test_config
+    dump_yml(HOME + "/config.yml", {'a'=>'conf', 'd'=>'conf', 'm' => 'conf'})
+    dump_yml(HOME + "/config/abra.yml", {'a'=>'app', 'd'=>'app', 'g' => 'app'})
+    cfg = Cerberus::Config.new('abra', :a => 'cli', :b=>'cli', :e=>'cli')
+
+    assert_equal nil, cfg[:mamba]
+    assert_equal 'cli', cfg[:a]
+    assert_equal 'cli', cfg[:b]
+    assert_equal 'app', cfg[:d]
+    assert_equal 'app', cfg[:g]
+    assert_equal 'conf', cfg[:m]
+
+  
+    assert_equal nil, cfg['mamba']
+    assert_equal 'cli', cfg['a']
+    assert_equal 'cli', cfg['b']
+    assert_equal 'app', cfg['d']
+    assert_equal 'app', cfg['g']
+    assert_equal 'conf', cfg['m']
+  end
+end

data/test/data/application.dump

@@ -0,0 +1,80 @@
+SVN-fs-dump-format-version: 2
+
+UUID: 3ede5f56-4031-f743-bcde-a87e4ff3590e
+
+Revision-number: 0
+Prop-content-length: 56
+Content-length: 56
+
+K 8
+svn:date
+V 27
+2006-06-29T09:59:06.497680Z
+PROPS-END
+
+Revision-number: 1
+Prop-content-length: 113
+Content-length: 113
+
+K 7
+svn:log
+V 10
+Added test
+K 10
+svn:author
+V 8
+Apomozov
+K 8
+svn:date
+V 27
+2006-06-29T10:48:02.581619Z
+PROPS-END
+
+Node-path: Rakefile
+Node-kind: file
+Node-action: add
+Prop-content-length: 10
+Text-content-length: 220
+Text-content-md5: b3f8886d55aca8f73578c7a896d1779a
+Content-length: 230
+
+PROPS-END
+require 'rake'
+require 'rake/testtask'
+
+task :default => :test
+
+desc "Run the unit tests in test/unit"
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+end
+
+
+Node-path: test
+Node-kind: dir
+Node-action: add
+Prop-content-length: 10
+Content-length: 10
+
+PROPS-END
+
+
+Node-path: test/a_test.rb
+Node-kind: file
+Node-action: add
+Prop-content-length: 10
+Text-content-length: 101
+Text-content-md5: 566f0fba7037bdfe73a4dc77368dabdc
+Content-length: 111
+
+PROPS-END
+require 'test/unit'
+
+class ATest < Test::Unit::TestCase
+  def test_ok
+    assert true
+  end
+end
+

data/test/functional_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+require 'cerberus/cli'
+
+#require 'mocks/notifier'
+
+class FunctionalTest < Test::Unit::TestCase
+  def setup
+    FileUtils.rm_rf HOME
+  end
+
+  def teardown
+    FileUtils.rm_rf HOME
+  end
+
+  def test_add_by_url
+    assert !File.exists?(HOME + '/config/svn_repo.yml')
+
+    command = Cerberus::Add.new("    #{SVN_URL}   ", :quiet => true)
+    command.run
+
+    assert File.exists?(HOME + '/config/svn_repo.yml')
+    assert_equal SVN_URL, load_yml(HOME + '/config/svn_repo.yml')['url']
+
+    assert File.exists?(HOME + '/config.yml')
+  end
+
+  def test_add_by_dir
+    sources_dir = File.dirname(__FILE__) + '/..'
+
+    command = Cerberus::Add.new(sources_dir, :quiet => true)
+    command.run
+
+    project_config = HOME + "/config/#{File.basename(File.expand_path(sources_dir))}.yml" #name of added application should be calculated from File System path
+
+    assert File.exists?(project_config)
+    assert_match %r{svn(\+ssh)?://(\w+@)?rubyforge.org/var/svn/cerberus}, load_yml(project_config)['url']
+
+    assert File.exists?(HOME + '/config.yml')
+  end
+
+  def test_build
+    add_application('myapp', SVN_URL)
+    
+    build = Cerberus::Build.new('myapp')
+    build.run
+    assert_equal 1, ActionMailer::Base.deliveries.size #first email that project was setup
+
+    status_file = HOME + '/work/myapp/status.log'
+    assert File.exists?(status_file)
+    assert_equal 'succesful', IO.read(status_file)
+
+    FileUtils.rm status_file
+    build = Cerberus::Build.new('myapp')
+    build.run
+    assert File.exists?(status_file)
+
+    assert_equal 2, ActionMailer::Base.deliveries.size #first email that project was setup
+
+    build = Cerberus::Build.new('myapp')
+    build.run
+    assert_equal 2, ActionMailer::Base.deliveries.size #Number of mails not changed
+
+
+    #remove status file to run project again
+    FileUtils.rm status_file
+    add_test_case_to_project('myapp', 'assert false') { #if assertion failed
+      build = Cerberus::Build.new('myapp')
+      build.run
+
+      assert_equal 'failed', IO.read(status_file)
+    }
+    assert_equal 3, ActionMailer::Base.deliveries.size #We should receive mail if project fails
+
+
+    #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::Build.new('myapp')
+      build.run
+
+      assert_equal 'failed', IO.read(status_file)
+    }
+  end
+
+  def test_have_no_awkward_header
+    add_application('myapp', SVN_URL)
+    
+    build = Cerberus::Build.new('myapp')
+    build.run
+
+    assert build.checkout.last_commit_message !~ /-rHEAD -v/
+    assert_equal 0, build.checkout.last_commit_message.index('-' * 72)
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+require 'yaml'
+
+class IntegrationTest < Test::Unit::TestCase
+  def setup
+    FileUtils.rm_rf HOME
+  end
+
+  def teardown
+    FileUtils.rm_rf HOME
+  end
+
+  def test_add_project_as_url
+    output = run_cerb("  add   #{SVN_URL}  ")
+    assert_match /was successfully added/, output
+    assert File.exists?(HOME + '/config/svn_repo.yml')
+    assert_equal SVN_URL, load_yml(HOME + '/config/svn_repo.yml')['url']
+
+    #try to add second time
+    output = run_cerb("add #{SVN_URL}")
+    assert_match /already present/, output
+    assert File.exists?(HOME + '/config/svn_repo.yml')
+    assert_equal SVN_URL, load_yml(HOME + '/config/svn_repo.yml')['url']
+  end
+
+  def test_add_project_with_parameters
+    output = run_cerb("  add   #{SVN_URL}  APPLICATION_NAME=hello_world RECIPIENTS=aa@gmail.com")
+    assert_match /was successfully added/, output
+
+    assert File.exists?(HOME + '/config/hello_world.yml')
+    cfg = load_yml(HOME + '/config/hello_world.yml')
+
+    assert_equal SVN_URL, cfg['url']
+    assert_equal 'aa@gmail.com', cfg['recipients']
+  end
+
+  def test_run_project
+    add_application('svn_repo', SVN_URL, 'quiet' => true)
+
+    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')
+  end
+
+  def test_run_unexist_project
+    output = run_cerb("build some_project")
+    assert_equal 'Project some_project does not present in Cerberus', output.strip
+    assert !test(?d, HOME + '/work/some_project')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,56 @@
+$:.unshift File.dirname(__FILE__) + '/../lib'
+require 'test/unit'
+require 'fileutils'
+
+require 'cerberus/utils'
+
+class Test::Unit::TestCase
+  include Cerberus::Utils
+
+  TEMP_DIR = File.expand_path(File.dirname(__FILE__)) + '/__workdir'
+
+  SVN_REPO = TEMP_DIR + '/svn_repo'
+  SVN_URL = 'file:///' + SVN_REPO.gsub(/\\/,'/').gsub(/^\//,'').gsub(' ', '%20')
+
+  HOME = TEMP_DIR + '/home'
+  ENV['CERBERUS_HOME'] = HOME
+
+  def self.refresh_subversion
+    FileUtils.rm_rf TEMP_DIR
+    FileUtils.mkpath SVN_REPO
+    `svnadmin create "#{SVN_REPO}"`
+    `svnadmin load "#{SVN_REPO}" < "#{File.dirname(__FILE__)}/data/application.dump"`
+  end
+
+  refresh_subversion
+
+  CERBERUS_PATH = File.expand_path(File.dirname(__FILE__) + '/../')
+  def run_cerb(args)
+    `ruby -I"#{CERBERUS_PATH}/lib" "#{CERBERUS_PATH}/bin/cerberus" #{args}`
+  end
+
+  def add_test_case_to_project(project_name, content)
+    test_case_name = "#{HOME}/work/#{project_name}/sources/test/#{rand(10000)}_test.rb"
+    File.open(test_case_name, 'w') { |f|
+      f << "require 'test/unit'
+
+class A#{rand(10000)}Test < Test::Unit::TestCase
+  def test_ok
+    #{content}
+  end
+end"
+    }
+
+    yield
+
+    FileUtils.rm test_case_name
+  end
+
+  def add_application(app_name, url, options = {})
+    opt = options.dup
+    opt['url'] = url
+    opt['recipients'] = 'somebody@com.com'
+    opt['mail'] = {'delivery_method' => 'test'}
+    dump_yml(HOME + "/config/#{app_name}.yml", opt)
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: cerberus
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2006-07-16 00:00:00 +04:00
+summary: Cerberus is a Continuous Integration tool that could be easily run from Cron.
+require_paths: 
+- lib
+email: anatol.pomozov@gmail.com
+homepage: http://rubyforge.org/projects/cerberus
+rubyforge_project: cerberus
+description: Cerberus is a Continuous Integration software for Ruby projects. CI helps you keep your project  in a good shape. For now Cerberus only work with projects that use Subversion but in the future it would be provided support for other VCS. Cerberus could be easily invoked from Cron (for Unix) or nnCron (for Windows) utilities.
+autorequire: 
+default_executable: cerberus
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Anatol Pomozov
+files: 
+- bin/cerberus
+- doc/FAQ
+- lib/cerberus
+- lib/cerberus/cli.rb
+- lib/cerberus/config.rb
+- lib/cerberus/constants.rb
+- lib/cerberus/latch.rb
+- lib/cerberus/manager.rb
+- lib/cerberus/utils.rb
+- lib/cerberus/version.rb
+- test/config_test.rb
+- test/data
+- test/functional_test.rb
+- test/integration_test.rb
+- test/test_helper.rb
+- test/data/application.dump
+- LICENSE
+- README
+- CHANGES
+- Rakefile
+test_files: 
+- test/integration_test.rb
+rdoc_options: 
+- --main
+- README
+extra_rdoc_files: 
+- README
+executables: 
+- cerberus
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: actionmailer
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.7.1
+    version: