abt 0.0.1

data/README.markdown

@@ -0,0 +1,68 @@
+# Always Be Testing!!!
+
+A test suite that uses IronWorker by http://www.iron.io to run it.
+
+## Getting Started
+
+First of all the, code to test must be able to check for a special config variable:
+
+    if defined? $abt_config
+      @config = $abt_config
+    end
+
+A real world example is here: https://github.com/iron-io/iron_mq_ruby/blob/master/test/test_base.rb
+
+Get it running locally first, here's an example:
+
+    worker = Abt::TestWorker.new
+    worker.git_url = "git://github.com/iron-io/iron_mq_ruby.git"
+    worker.test_config = @test_config
+    worker.run_local
+
+Add notifier
+
+    worker.add_notifier("HipchatNotifier",{"hipchat_api_key"=>'secret_api_key',"room_name"=>'Room Name',"title"=>"From"})
+and/or
+    worker.add_notifier("WebHookNotifier",{"url"=>'notification_url'})
+you could add as many notifiers as you need
+
+Then try queuing it up.
+
+    worker.queue
+
+If that works all good, then:
+
+## Schedule It!
+
+Schedule it to run regularly to ensure you're always being covered.
+
+    worker.schedule(:start_at=>Time.now, :run_every=>3600)
+
+## Custom notifiers
+
+###All you need:
+
+* Implement in your notifier following methods:
+
+setup configuration:
+
+    def initialize(notifier_details)
+      @url = notifier_details["url"]
+    end
+
+process simple text message
+
+    def send_message(message)
+      puts message
+    end
+
+if you need you could process more detailed results, 'result' is an instance of Test::Unit::TestResult
+
+    def send_formatted_message(result)
+     result.inspect
+    end
+
+
+* Add your custom notifier into 'notifiers' folder or just merge it
+* Add your notifier to worker
+    worker.add_notifier("YourCustomNotifierClass",{"option_name"=>'option_value'})

data/VERSION.yml

@@ -0,0 +1,5 @@
+---
+:major: 0
+:minor: 0
+:patch: 1
+:build: 

data/lib/abt.rb

@@ -0,0 +1 @@
+require_relative 'abt/test_worker'

data/lib/abt/notifiers/hipchat_notifier.rb

@@ -0,0 +1,29 @@
+class HipchatNotifier
+  require 'hipchat-api'
+
+  def initialize(notifier_details)
+    @client = HipChat::API.new(notifier_details["hipchat_api_key"])
+    @room_name = notifier_details["room_name"]
+    @title= notifier_details["title"]
+  end
+
+  def send_formatted_message(result)
+    color = result.passed? ? 'green' : 'red'
+    message = "Result: <b>#{result.status}</b> [#{result.pass_percentage}%] <br>
+     <strong>#{result.run_count}</strong> tests, <strong>#{result.assertion_count}</strong> assertions"
+    if result.error_occurred? || result.failure_occurred?
+     message+=", <strong>#{result.failure_count}</strong> failures, <strong>#{result.error_count}</strong>, errors<br/>"
+      result.faults.each { |f| message+="<br><pre>#{f.to_s.gsub(/>/,' ').gsub(/</,' ')}</pre><br/>" }
+     end
+    send_message(message,color)
+  end
+
+  def send_message(message,color='yellow')
+    puts "sending_message #{message}"
+    begin
+      puts @client.rooms_message(@room_name, @title, message, false,color).body
+    rescue =>ex
+      ex.inspect
+    end
+  end
+end

data/lib/abt/notifiers/web_hook_notifier.rb

@@ -0,0 +1,27 @@
+class WebHookNotifier
+  require 'rest-client'
+
+  def initialize(notifier_details)
+    @url = notifier_details["url"]
+  end
+
+  def send_message(message)
+    puts "sending_message #{message}"
+    post(message)
+  end
+
+  def post(message)
+    begin
+      RestClient.post(@url, {:message=>message}, headers)
+    rescue RestClient::Exception => ex
+      ex.inspect
+    end
+  end
+
+  def headers
+    #coudl be added oauth token
+    {'User-Agent' => "ABT Ruby Client"}
+  end
+
+
+end

data/lib/abt/test_collector.rb

@@ -0,0 +1,89 @@
+require 'test/unit/autorunner'
+require 'test/unit'
+
+module Test
+  module Unit
+    AutoRunner.prepare do |auto_runner|
+      Notify.setup_auto_runner(auto_runner)
+    end
+
+    AutoRunner.setup_option do |auto_runner|
+      Notify.setup_auto_runner(auto_runner)
+    end
+
+    module Notify
+      class << self
+        def setup_auto_runner(auto_runner) # :nodoc:
+          auto_runner.listeners.reject! do |listener|
+            listener.is_a?(Notify::Notifier)
+          end
+          auto_runner.listeners << Notifier.new
+        end
+      end
+
+      class Notifier
+
+        def self.add_params(params={})
+          @params||={}
+          @params.merge!(params)
+        end
+
+        def self.get_params
+          @params||{}
+        end
+
+        def self.add_notifier(sender)
+          @senders||=[]
+          @senders<<sender
+          puts "adding sender!#{@senders.inspect}"
+        end
+
+        def self.get_notifiers
+          @senders||[]
+        end
+
+        def attach_to_mediator(mediator)
+          mediator.add_listener(UI::TestRunnerMediator::STARTED,
+                                &method(:started))
+          mediator.add_listener(UI::TestRunnerMediator::FINISHED,
+                                &method(:finished))
+        end
+
+        def started(result)
+          @result = result
+        end
+
+        def notify?(params,result)
+          return true unless result.passed?
+          if params && params[:notify_every]
+            ((Time.now.hour % params[:notify_every].to_i == 0) && Time.now.min > 0 && Time.now.min < 10)
+          else
+            true
+          end
+        end
+
+        def finished(elapsed_time)
+          message = "Status:%s [%g%%] (%gs)" % [@result.status,
+                                                @result.pass_percentage,
+                                                elapsed_time]
+          puts "Message:#{message}:"
+          puts "TEST_RESULT:#{@result.inspect}"
+          params = Notifier.get_params
+          senders = Notifier.get_notifiers
+          senders.each do |sender|
+            puts "sender:#{sender.inspect}"
+            puts "Notify?:#{notify?(params,@result).inspect}"
+            if sender && notify?(params,@result)
+              if sender.respond_to?(:send_formatted_message)
+                puts sender.send_formatted_message(@result)
+              elsif sender.respond_to?(:send_message)
+                puts sender.send_message(message)
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/abt/test_worker.rb

@@ -0,0 +1,147 @@
+require 'iron_worker'
+require 'json'
+# bump.....
+ARGV=[]
+module Abt
+  #
+  #class MiniTestWithHooks < MiniTest::Unit
+  #  def before_suites
+  #  end
+  #
+  #  def after_suites
+  #  end
+  #
+  #  def _run_suites(suites, type)
+  #    puts 'run_suites ' + suites.inspect + ' type=' + type.inspect
+  #    begin
+  #      before_suites
+  #      super(suites, type)
+  #    ensure
+  #      after_suites
+  #    end
+  #  end
+  #
+  #
+  #
+  #  def _run_suite(suite, type)
+  #    puts 'run_suite ' + suite.inspect + ' type=' + type.inspect
+  #    begin
+  #      # suite.before_suite
+  #      super(suite, type)
+  #    ensure
+  #      # suite.after_suite
+  #    end
+  #  end
+  #end
+  #
+  #..
+  class TestWorker < IronWorker::Base
+    merge_gem 'minitest', :require=>['minitest/unit', 'minitest/autorun']
+    merge_gem 'test-unit', :require=>['test/unit/priority', 'test/unit/testcase', 'test/unit/assertions', 'test/unit']
+    merge_gem 'git'
+    merge_gem 'hipchat-api'
+    merge_gem 'bundler'
+    merge 'test_collector'
+    merge_folder 'notifiers'
+    attr_accessor :git_url, :test_config, :notifiers, :notify_every
+
+    def add_notifier(notifier_name, notifier_details={})
+      @notifiers||=[]
+      @notifiers<<{"notifier_name"=>notifier_name, "notifier_details"=>notifier_details}
+    end
+
+    def run
+      if is_remote?
+        require File.join(File.dirname(__FILE__), '/gems/minitest/lib/minitest/unit')
+        require File.join(File.dirname(__FILE__), '/gems/test-unit/lib/test/unit/priority')
+        require File.join(File.dirname(__FILE__), '/gems/test-unit/lib/test/unit/testcase')
+        require File.join(File.dirname(__FILE__), '/gems/test-unit/lib/test/unit/assertions')
+        require File.join(File.dirname(__FILE__), '/gems/test-unit/lib/test/unit')
+        require File.join(File.dirname(__FILE__), '/gems/minitest/lib/minitest/autorun')
+      end
+        # Test::Unit.run = false
+        #MiniTest::Unit.runner = MiniTestWithHooks.new
+        # g = Git.open(user_dir, :log => Logger.new(STDOUT))
+      clone_dir = 'cloned'
+      x = File.join(user_dir, clone_dir)
+      p x
+      if is_local?
+        FileUtils.rm_rf(File.join(user_dir, clone_dir))
+      end
+
+      $abt_config = self.test_config
+
+      puts "cloning #{git_url}..."
+      g = Git.clone(git_url, clone_dir, :path => user_dir)
+      old_specs = nil
+      current_gemfile = File.join(File.expand_path(user_dir+clone_dir+'/test'), 'Gemfile')
+      log "GEMFILE:#{current_gemfile}"
+      log "DIR:#{File.join(user_dir+clone_dir+'/test')}"
+      if File.exist?(current_gemfile)
+        log "Bundling gems"
+        system "cd #{File.join(user_dir+clone_dir+'/test')}; bundle install --deployment"
+        log "Gemfile:#{current_gemfile}"
+        old_specs = Gem.loaded_specs.dup
+        Gem.loaded_specs.clear
+        ENV['BUNDLE_GEMFILE'] = current_gemfile
+        log "Bundling!"
+        require 'bundler/setup'
+        log "List of gems from Gemfile: #{Gem.loaded_specs.inspect}"
+      end
+      Dir.glob(File.join(user_dir, clone_dir, 'test', 'test_*')).each { |f|
+        puts "requiring #{f}"
+        require f
+      }
+
+      Test::Unit::Notify::Notifier.add_params({:notify_every=>notify_every}) if notify_every
+      if notifiers
+        notifiers.each do |notifier|
+          puts "NOTIFIER:#{notifier.inspect}"
+          Test::Unit::Notify::Notifier.add_notifier(Kernel.const_get(notifier["notifier_name"]).new(notifier["notifier_details"]))
+        end
+      end
+      Test::Unit::AutoRunner.run
+
+      if old_specs
+        Gem.loaded_specs.clear
+        old_specs.each do |k, v|
+          log "Loading gem:#{k}"
+          Gem.loaded_specs[k]=v
+        end
+        log "Full list of gems: #{Gem.loaded_specs.inspect}"
+      end
+
+    end
+    # ...
+    #  def suite_results_output(options={})
+    #    line_break = "\n"
+    #    if options[:format] == 'html'
+    #      line_break = "<br/>"
+    #    end
+    #    s = "Suite Results:#{line_break}"
+    #    s << "#{@num_failed} failed out of #{@num_tests} tests.#{line_break}"
+    #    if @num_failed > 0
+    #      @failed.each do |f|
+    #        s << "#{f.test_class}.#{f.test_method} failed: #{f.result.message}#{line_break}"
+    #      end
+    #    end
+    #    s << "Test suite duration: #{duration}ms.#{line_break}"
+    #    s
+    #  end
+    #
+    #  def duration
+    #    ((@end_time.to_f - @start_time.to_f) * 1000.0).to_i
+    #  end
+    #
+    #  def time_in_ms(t)
+    #    (t.to_f * 1000.0).to_i
+    #  end
+    #
+    #  # callbacks
+    #  def on_complete
+    #
+    #  end
+    #
+  end
+
+end

metadata

@@ -0,0 +1,164 @@
+--- !ruby/object:Gem::Specification
+name: abt
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  segments:
+  - 0
+  - 0
+  - 1
+  prerelease: false
+  segments_generated: true
+platform: ruby
+authors:
+- Travis Reeder
+autorequire: !!null 
+bindir: bin
+cert_chain: []
+date: 2012-02-06 00:00:00.000000000 -08:00
+default_executable: !!null 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: &24643100 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24643100
+- !ruby/object:Gem::Dependency
+  name: iron_worker
+  requirement: &24641240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24641240
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: &24639900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24639900
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: &24638780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24638780
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &24637480 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24637480
+- !ruby/object:Gem::Dependency
+  name: git
+  requirement: &24636300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24636300
+- !ruby/object:Gem::Dependency
+  name: iron_worker
+  requirement: &24590740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+        segments:
+        - 0
+        segments_generated: true
+  type: :runtime
+  prerelease: false
+  version_requirements: *24590740
+description: Always Be Testing Yo! A testing framework that runs on IronWorker http://www.iron.io
+email: travis@iron.io
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.markdown
+files:
+- VERSION.yml
+- lib/abt.rb
+- lib/abt/notifiers/hipchat_notifier.rb
+- lib/abt/notifiers/web_hook_notifier.rb
+- lib/abt/test_collector.rb
+- lib/abt/test_worker.rb
+- README.markdown
+has_rdoc: true
+homepage: https://github.com/iron-io/abt
+licenses: []
+post_install_message: !!null 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.9'
+      segments:
+      - 1
+      - 9
+      segments_generated: true
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      segments_generated: true
+requirements: []
+rubyforge_project: !!null 
+rubygems_version: 1.3.7
+signing_key: !!null 
+specification_version: 3
+summary: Always Be Testing Yo! A testing framework that runs on IronWorker http://www.iron.io
+test_files: []