infinity_test 0.1.0

data/lib/infinity_test/dependencies.rb

@@ -0,0 +1,45 @@
+
+RVM_LIBRARY_DIRECTORY = File.expand_path("~/.rvm/lib")
+
+#
+# Try to require the rvm in home folder
+# If not suceed raise a LoadError 
+# Try to see if the user has the RVM 1.0 or higher for the RVM Ruby API
+# If not raise a NameError
+#
+def require_home_rvm
+  $LOAD_PATH.unshift(RVM_LIBRARY_DIRECTORY) unless $LOAD_PATH.include?(RVM_LIBRARY_DIRECTORY)
+  require 'rvm'
+  RVM::Environment
+end
+
+# TODO: Make require with System Wide Install too
+#
+begin
+  require_home_rvm
+rescue LoadError, NameError
+  puts
+  puts "It appears that you have not installed the RVM in #{RVM_LIBRARY_DIRECTORY} or RVM is very old.\n"
+  puts "The RVM is installed?"
+  puts "If not, please see http://rvm.beginrescueend.com/rvm/install/"
+  puts "If so, try to run:"
+  puts "\t rvm update --head"
+  puts "If the error continues, please create an issue in http://github.com/tomas-stefano/infinity_test"
+  puts 'Thanks :)'
+  exit
+end
+
+def require_without_rubygems(options)
+  gem_name = options[:gem]
+  begin
+    require gem_name
+  rescue LoadError
+    require 'rubygems'
+    require gem_name
+  end
+end
+
+require_without_rubygems :gem => 'watchr'
+
+require 'ostruct'
+

data/lib/infinity_test/notifications/growl.rb

@@ -0,0 +1,15 @@
+module InfinityTest
+  module Notifications
+    class Growl
+      
+      # Notification via Growl
+      #
+      # Growl.new.notify(:ruby_version => "Ruby 1.9.2", :message => "0 examples, 0 failures", :image => 'image.png')
+      #
+      def notify(options)
+        system "growlnotify -n infinity_test -m '#{options[:message]}' -t 'Ruby #{options[:title]}' --image #{options[:image]} -n infinity_test"
+      end
+      
+    end
+  end
+end

data/lib/infinity_test/notifications/lib_notify.rb

@@ -0,0 +1,11 @@
+module InfinityTest
+   module Notifications
+     class LibNotify
+       
+       def notify(options)
+         system "notify-send --expire-time 3000 --icon #{options[:image]} 'Ruby #{options[:title]}' '#{options[:message]}'"
+       end
+       
+     end
+   end
+end

data/lib/infinity_test/options.rb

@@ -0,0 +1,52 @@
+require 'optparse'
+
+module InfinityTest
+  class Options < Hash
+        
+    def initialize(arguments)
+      super()
+      @options = OptionParser.new do |options|
+        parse_rspec(options)
+        parse_test_unit(options)
+        parse_rubies(options)
+        parse_verbose(options)
+        options.banner = [ "Usage: infinity_test [options]", "Starts a continuous test server."].join("\n")        
+        options.on_tail("--help", "You're looking at it.") do
+          print options.help
+          exit
+        end
+      end
+      @options.parse!(arguments.clone)
+    end
+    
+    def parse_rspec(options)
+      options.on('--rspec', 'Rspec Framework') do
+        self[:test_framework] = :rspec
+      end
+    end
+    
+    def parse_test_unit(options)
+      options.on('--test-unit', 'Test Unit') do
+        self[:test_framework] = :test_unit
+      end
+    end
+    
+    def parse_rubies(options)
+      options.on('--rubies=rubies', 'Specify the Ruby Versions for Testing with several Rubies') do |versions|
+        self[:rubies] = versions
+      end
+    end
+    
+    def parse_verbose(options)
+      options.on('--verbose', 'The Infinity Test dont print the commands. To print the command set this options!') do
+        self[:verbose] = true
+      end
+    end
+    
+    def rspec?
+      return true if self[:test_framework].equal?(:rspec)
+      false
+    end
+    
+  end
+end

data/lib/infinity_test/rspec.rb

@@ -0,0 +1,87 @@
+module InfinityTest
+  class Rspec
+    include BinaryPath
+    attr_accessor :rubies, :test_directory_pattern, :message, :test_pattern, 
+                  :failure, :sucess, :pending
+    
+    #
+    # rspec = InfinityTest::Rspec.new(:rubies => '1.9.1,1.9.2')
+    # rspec.rubies # => '1.9.1,1.9.2'
+    #
+    def initialize(options={})
+      @rubies = options[:rubies] || []
+      @test_directory_pattern = "^spec/*/(.*)_spec.rb"
+      @test_pattern = options[:test_pattern] || 'spec/**/*_spec.rb'
+    end
+    
+    def construct_commands(file=nil)
+      @rubies << RVM::Environment.current.environment_name if @rubies.empty?
+      construct_rubies_commands(file)
+    end
+    
+    def all_files
+      Dir[@test_pattern]
+    end
+    
+    def spec_files
+      all_files.collect { |file| file }.join(' ')
+    end
+    
+    def construct_rubies_commands(file=nil)
+      results = Hash.new
+      RVM.environments(@rubies) do |environment|
+        ruby_version = environment.environment_name
+        rspec_binary = search_rspec_two(environment)
+        rspec_binary = search_rspec_one(environment) unless File.exist?(rspec_binary)
+        unless have_binary?(rspec_binary)
+          print_message('rspec', ruby_version)
+        else
+          results[ruby_version] = "rvm #{ruby_version} ruby #{rspec_binary} #{decide_files(file)}"
+        end
+      end
+      results
+    end
+    
+    # TODO: I'm not satisfied yet
+    #
+    def decide_files(file)
+      return file if file
+      spec_files
+    end
+    
+    def search_rspec_two(environment)
+      search_binary('rspec', :environment => environment)
+    end
+    
+    def search_rspec_one(environment)
+      search_binary('spec', :environment => environment)
+    end
+    
+    def parse_results(results)
+      shell_result = results.split("\n").last
+      if shell_result =~ /example/
+        @example = shell_result[/(\d+) example/, 1].to_i
+        @failure = shell_result[/(\d+) failure/, 1].to_i
+        @pending = shell_result[/(\d+) pending/, 1].to_i
+        @message = "#{@example} examples, #{@failure} failures, #{@pending} pending"
+      else
+        @example, @pending, @failure = 0, 0, 1
+        @message = "An exception occurred"
+      end
+    end
+    
+    def sucess?
+      return false if failure? or pending?
+      true
+    end
+    
+    def failure?
+      @failure > 0
+    end
+    
+    def pending?
+      @pending > 0 and not failure?
+    end
+    
+  end
+end

data/lib/infinity_test/runner.rb

@@ -0,0 +1,30 @@
+module InfinityTest
+  class Runner
+    attr_reader :commands, :options, :application
+    
+    def initialize(options)
+      @options = options
+      @commands = []
+      @application = InfinityTest.application
+    end
+    
+    def run!
+      load_configuration_file_or_read_the_options!
+      start_continuous_testing!
+    end
+    
+    def load_configuration_file_or_read_the_options!
+      @application.load_configuration_file
+      @application.config.use(
+        :rubies => (options[:rubies] || @application.rubies),
+        :test_framework => (options[:test_framework] || @application.config.test_framework),
+        :verbose => options[:verbose] || @application.config.verbose
+      )
+    end
+    
+    def start_continuous_testing!
+      InfinityTest::ContinuousTesting.new(:application => @application).start!
+    end
+
+  end
+end

data/lib/infinity_test/test_unit.rb

@@ -0,0 +1,74 @@
+module InfinityTest
+  class TestUnit
+    attr_reader :rubies, :message, :test_directory_pattern, :tests, 
+                :assertions, :failures, :errors
+    
+    def initialize(options={})
+      @rubies = options[:rubies] || []
+      @test_directory_pattern = "^test/*/(.*)_test.rb"
+      @test_pattern = 'test/**/*_test.rb'
+    end
+    
+    def construct_commands(file=nil)
+      @rubies << RVM::Environment.current.environment_name if @rubies.empty?
+      construct_rubies_commands(file)
+    end
+    
+    def construct_rubies_commands(file=nil)
+      results = Hash.new
+      RVM.environments(@rubies) do |environment|
+        ruby_version = environment.environment_name
+        results[ruby_version] = "rvm #{ruby_version} ruby -I'lib:test' #{decide_files(file)}"
+      end
+      results
+    end
+    
+    def decide_files(file)
+      return file if file
+      test_files
+    end
+    
+    def test_files
+      collect_test_files.unshift(test_loader).join(' ')
+    end
+
+    def collect_test_files
+      all_files.collect { |file| file }
+    end
+    
+    def all_files
+      Dir[@test_pattern]
+    end
+
+    def test_loader
+      $LOAD_PATH.each do |path|
+        file_path = File.join(path, "infinity_test/test_unit_loader.rb")    
+        return file_path if File.exist?(file_path)
+      end
+    end
+    
+    def parse_results(results)
+      shell_result = results.split("\n")
+      shell_result = shell_result.select { |line| line =~ /(\d+) tests/}.first
+      if shell_result
+        @tests    = shell_result[/(\d+) tests/, 1].to_i
+        @assertions = shell_result[/(\d+) assertions/, 1].to_i
+        @failures = shell_result[/(\d+) failures/, 1].to_i
+        @errors   = shell_result[/(\d+) errors/, 1].to_i
+        @message = shell_result
+      else
+        @tests, @assertions, @failures, @errors = 0, 0, 1, 1
+        @message = "An exception ocurred"
+      end
+    end
+    
+    def failure?
+      @failures > 0 or @errors > 0
+    end
+    
+    def pending?
+      false # Don't have pending in Test::Unit right?? #doubt
+    end
+
+  end
+end

data/lib/infinity_test/test_unit_loader.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+# Load the test files from the command line.
+
+ARGV.each { |file| load file unless file =~ /^-/  }

data/spec/factories/infinity_test

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+infinity_test do
+  use :rubies => ['1.8.7-p249' ,'1.9.1', '1.9.2'], :test_framework => :rspec
+end

data/spec/factories/infinity_test_example

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+infinity_test do
+
+  use :rubies => ['1.8.7-p249' ,'1.9.1'], :test_framework => :test_unit
+  
+end

data/spec/infinity_test/application_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+module InfinityTest
+  describe Application do
+    let(:application) { Application.new }
+    
+    before(:each) do
+      @application = Application.new
+    end
+    
+    it "should return test_unit pattern for test unit" do
+      @application.library_directory_pattern.should eql "^lib/*/(.*)\.rb"
+    end
+    
+    it "should return the rubies in the config" do
+      application_with(:rubies => ['1.8.7']).rubies.should == '1.8.7'
+    end
+    
+    it "should return the rubies in the config" do
+      application_with(:rubies => ['1.9.2']).rubies.should == '1.9.2'
+    end
+    
+    it "should return the before callback" do
+      app = application_with(:test_framework => :rspec)
+      proc = Proc.new { 'To Infinity and beyond!' }
+      app.config.before_run(&proc)
+      app.before_callback.should equal proc
+    end
+
+    it "should return the block when set after callback" do
+      app = application_with(:test_framework => :rspec)
+      proc = Proc.new { 'To Infinity and beyond!' }
+      app.config.after_run(&proc)
+      app.after_callback.should equal proc
+    end
+   
+    describe '#image_to_show' do
+
+      before do
+        @application_with_rspec = application_with(:test_framework => :rspec)
+        @application_with_test_unit = application_with(:test_framework => :test_unit)
+      end
+
+      it "should return sucess when pass all the tests" do
+        test_should_not_fail!(@application_with_rspec)
+        test_should_not_pending!(@application_with_rspec)
+        @application_with_rspec.image_to_show.should match /sucess/
+      end
+
+      it "should return failure when not pass all the tests" do
+        test_should_fail!(@application_with_rspec)
+        @application_with_rspec.image_to_show.should match /failure/
+      end
+
+      it "should return pending when have pending tests" do
+        test_should_not_fail!(@application_with_rspec)
+        test_should_pending!(@application_with_rspec)
+        @application_with_rspec.image_to_show.should match /pending/
+      end
+
+      def test_should_not_fail!(object)
+        object.test_framework.should_receive(:failure?).and_return(false)      
+      end
+
+      def test_should_fail!(object)
+        object.test_framework.should_receive(:failure?).and_return(true)
+      end
+
+      def test_should_pending!(object)
+        object.test_framework.should_receive(:pending?).and_return(true)      
+      end
+
+      def test_should_not_pending!(object)
+        object.test_framework.should_receive(:pending?).and_return(false)      
+      end
+
+    end
+    
+    describe '#notification_framework' do
+
+      it "should return the Growl notification framework if has :growl" do
+        application.config.notifications :growl
+        application.notification_framework.should be_instance_of InfinityTest::Notifications::Growl
+      end
+      
+      it "should return the Lib Notify if has :lib_notify" do
+        application.config.notifications :lib_notify
+        application.notification_framework.should be_instance_of InfinityTest::Notifications::LibNotify
+      end
+
+      it "should cache notification" do
+        application.config.notifications :lib_notify
+        notification = application.notification_framework
+        application.notification_framework.should equal notification
+      end
+
+    end
+    
+    describe '#test_framework' do
+      
+      before do
+        @application = Application.new
+      end
+      
+      it "should return the instance of Rspec when test framework is Rspec" do
+        @application.config.use :test_framework => :rspec
+        @application.test_framework.should be_instance_of(InfinityTest::Rspec)
+      end
+
+      it "should return the instance of Rspec when test framework is Rspec" do
+        @application.config.use :test_framework => :test_unit
+        @application.test_framework.should be_instance_of(InfinityTest::TestUnit)
+      end
+      
+      it "should pass all the rubies for the test_framework TestUnit" do
+        @application.config.use :test_framework => :test_unit, :rubies => ['1.9.1', '1.9.2']
+        TestUnit.should_receive(:new).with(:rubies => '1.9.1,1.9.2')
+        @application.test_framework
+      end
+
+      it "should pass all the rubies for the test_framework Rspec" do
+        @application.config.use :test_framework => :rspec, :rubies => ['1.9.1', '1.9.2']
+        Rspec.should_receive(:new).with(:rubies => '1.9.1,1.9.2')
+        @application.test_framework
+      end
+      
+      it "should cache the test framework instance" do
+        @application.config.use :test_framework => :rspec
+        test_framework = @application.test_framework
+        @application.test_framework.should equal test_framework
+      end
+
+    end
+    
+    describe '#verbose?' do
+
+      it "should return to false when not set verbose" do
+        @application.verbose?.should equal false
+      end
+         
+      it "should return true when set verbose to true" do
+        @application.config.verbose = true
+        @application.verbose?.should be_true
+      end
+      
+    end
+
+  end
+end