infinity_test 1.0.3 → 2.0.0.rc1

data/lib/infinity_test/options.rb

@@ -1,96 +0,0 @@
-require 'optparse'
-
-module InfinityTest
-  class Options < Hash
-
-    def initialize(arguments)
-      super()
-      @options = OptionParser.new do |options|
-        [:test_unit, :rspec, :bacon, :rubygems, :rails, :rubies, :verbose, :patterns, :bundler, :version].each do |name|
-          send("parse_#{name}", options)
-        end
-        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', 'Test Framework: RSpec') do
-        self[:test_framework] = :rspec
-      end
-    end
-
-    def parse_test_unit(options)
-      options.on('--test-unit', 'Test Framework: Test Unit (Default)') do
-        self[:test_framework] = :test_unit
-      end
-    end
-
-    def parse_bacon(options)
-      options.on('--bacon', 'Test Framework: Bacon') do
-        self[:test_framework] = :bacon
-      end
-    end
-
-    def parse_rubies(options)
-      options.on('--rubies=rubies', 'Specify Ruby version(s) to test against') do |versions|
-        rubies = []
-        self[:specific_options] = {}
-        versions.split(",").each do |r|
-          rubie = r.split('+')[0]
-          params = r.split('+')[1]
-          self[:specific_options][rubie] = params 
-          rubies << rubie
-        end
-        self[:rubies] = rubies.join(',')
-      end
-    end
-
-    def parse_verbose(options)
-      options.on('--verbose', 'Print commands before executing them') do
-        self[:verbose] = true
-      end
-    end
-
-    def parse_rails(options)
-      options.on('--rails', 'Application Framework: Rails') do
-        self[:app_framework] = :rails
-      end
-    end
-
-    def parse_rubygems(options)
-      options.on('--rubygems', 'Application Framework: Rubygems (Default)') do
-        self[:app_framework] = :rubygems
-      end
-    end
-
-    # def parse_cucumber(options)
-    #   options.on('--cucumber', 'Run with the Cucumber too') do
-    #     self[:cucumber] = true
-    #   end
-    # end
-
-    def parse_patterns(options)
-      options.on('--heuristics', 'Show all defined heuristics and exit') do
-        self[:show_heuristics?] = true
-      end
-    end
-
-    def parse_bundler(options)
-      options.on('--skip-bundler', "Bypass Infinity Test's Bundler support, even if a Gemfile is present") do
-        self[:skip_bundler?] = true
-      end
-    end
-
-    def parse_version(options)
-      options.on("--version", "Show version and exit") do
-        puts InfinityTest.version
-        exit
-      end
-    end
-  end
-end

data/lib/infinity_test/runner.rb

@@ -1,38 +0,0 @@
-module InfinityTest
-  class Runner
-    attr_reader :options, :application
-
-    def initialize(argv)
-      @options = Options.new(argv)
-      @application = InfinityTest.application
-    end
-
-    def run!
-      load_configuration_file_or_read_the_options!
-      if @options[:show_heuristics?]
-        list_heuristics!
-      else
-        @application.run_global_commands!
-        start_continuous_testing!
-      end
-    end
-
-    def list_heuristics!
-      @application.heuristics.patterns.keys.each do |pattern|
-        puts %{- "#{pattern}"}
-      end
-      exit
-    end
-
-    def load_configuration_file_or_read_the_options!
-      @application.load_configuration_file_or_read_the_options!(@options)
-    end
-
-    # Start Continuous Server using Watchr
-    #
-    def start_continuous_testing!
-      InfinityTest::ContinuousTesting.new.start!
-    end
-
-  end
-end

data/lib/infinity_test/test_framework.rb

@@ -1,110 +0,0 @@
-module InfinityTest
-  class TestFramework
-    include InfinityTest::BinaryPath
-    include InfinityTest::Environment
-    include InfinityTest::Builder
-
-    binary :bundle
-
-    attr_accessor :application, :message, :rubies, :test_pattern, :specific_options
-
-    def initialize(options={})
-      @application = InfinityTest.application
-      @rubies = options[:rubies] || []
-      @specific_options = options[:specific_options] || {}
-    end
-
-    # Return all the files match by test_pattern
-    #
-    def all_files
-      Dir[@test_pattern].sort
-    end
-
-    def test_files
-      all_files.collect { |file| file }.join(' ')
-    end
-
-    def decide_files(file)
-      return file if file
-      test_files
-    end
-
-    # Method used in the subclasses of TestFramework
-    #
-    # Example:
-    #
-    #  class Rspec < TestFramework
-    #    parse_results :example => /(\d+) example/, :failure => /(\d+) failure/, :pending => /(\d+) pending/
-    #  end
-    #
-    # Then will create @examples, @failure and @pending instance variables with the values in the test result
-    #
-    # Or with Test::Unit:
-    #
-    #  class TestUnit < TestFramework
-    #    parse_results :tests => /(\d+) tests/, :assertions => /(\d+) assertions/, :failures => /(\d+) failures/, :errors => /(\d+) errors/
-    #  end
-    #
-    # Then will create @tests, @assertions, @failures and @errors instance variables with the values in the test result
-    #
-    def self.parse_results(patterns)
-      raise(ArgumentError, 'patterns should not be empty') if patterns.empty?
-      create_accessors(patterns)
-      define_method(:parse_results) do |results|
-        set_instances(:shell_result => test_message(results, patterns), :patterns => patterns)
-      end
-    end
-
-    # Create accessors for keys of the Hash passed in argument
-    #
-    # create_accessors({ :example => '...', :failure => '...'}) # => attr_accessor :example, :failure
-    #
-    def self.create_accessors(hash)
-      hash.keys.each do |attribute|
-        attr_accessor attribute
-      end
-    end
-
-    # Create the instance pass in the patterns options
-    #
-    # Useful for the parse results:
-    #  parse_results :tests => /.../, :assertions => /.../
-    #
-    # Then will create @tests ans @assertions (the keys of the Hash)
-    #
-    def create_pattern_instance_variables(patterns, shell_result)
-      patterns.each do |key, pattern|
-        number = shell_result[pattern, 1].to_i
-        instance_variable_set("@#{key}", number)
-      end
-      @message = shell_result.gsub(/\e\[\d+?m/, '') # Clean ANSIColor strings
-    end
-
-    # Return the message of the tests
-    #
-    # test_message('0 examples, 0 failures', { :example => /(\d) example/}) # => '0 examples, 0 failures'
-    # test_message('....\n4 examples, 0 failures', { :examples => /(\d) examples/}) # => '4 examples, 0 failures'
-    #
-    def test_message(output, patterns)
-      lines = output.split("\n")
-      final_result = []
-      patterns.each do |key, pattern|
-        final_result << lines.select { |line| line =~ pattern }
-      end
-      final_result.flatten.last
-    end
-
-    private
-
-      def set_instances(options)
-        shell_result, patterns = options[:shell_result], options[:patterns]
-        if shell_result
-          create_pattern_instance_variables(patterns, shell_result)
-        else
-          patterns.each { |instance, pattern| instance_variable_set("@#{instance}", 1) } # set all to 1 to show that an error occurred
-          @message = "An exception occurred"
-        end
-      end
-
-  end
-end

data/lib/infinity_test/test_library/bacon.rb

@@ -1,55 +0,0 @@
-module InfinityTest
-  module TestLibrary
-    class Bacon < TestFramework
-      binary :bacon
-      parse_results :specifications => /(\d+) specifications/, :requirements => /(\d+) requirements/, :failures => /(\d+) failure/, :errors => /(\d+) errors/
-
-      # Bacon Framework
-      #
-      # For more information about the Bacon see: http://github.com/chneukirchen/bacon
-      #
-      # bacon = InfinityTest::Bacon.new(:rubies => '1.9.1,1.9.2')
-      # bacon.rubies # => '1.9.1,1.9.2'
-      # bacon.test_directory_pattern # => "^spec/*/(.*)_spec.rb"
-      # bacon.test_pattern # => 'spec/**/*_spec.rb'
-      #
-      def initialize(options={})
-        super(options)
-        @test_pattern = 'spec/**/*_spec.rb'
-      end
-
-      # Construct all the commands for each ruby
-      # First, try to find the bacon binary, and raise/puts an Error if don't find it.
-      # After that, verifying if the user have a Gemfile, and if has, run with "bundle exec" command, else will run normally
-      #
-      def construct_rubies_commands(file=nil)
-        commands = {}
-        environments do |environment, ruby_version|
-          bacon_binary = search_bacon(environment)
-          command = construct_command(
-                        :for => ruby_version,
-                        :binary => bacon_binary,
-                        :load_path => 'lib:spec',
-                        :file => file,
-                        :environment => environment) || next
-          commands[ruby_version] = command
-        end
-        commands
-      end
-
-      def sucess?
-        return false if failure?
-        true
-      end
-
-      def failure?
-        @failures > 0
-      end
-
-      def pending?
-        false # Don't have pending in Bacon
-      end
-
-    end
-  end
-end

data/lib/infinity_test/test_library/cucumber.rb

@@ -1,22 +0,0 @@
-module InfinityTest
-  module TestLibrary
-    class Cucumber < TestFramework
-      include HeuristicsHelper
-      binary :cucumber
-      parse_results :passed => /(\d+) passed/, :failed => /(\d+) failed/
-
-      def initialize
-        add_heuristics!
-      end
-
-      def add_heuristics!
-        heuristics do
-          add("^features/*/*feature") do
-            run :all => :tests, :in_dir => :steps_definitions
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/infinity_test/test_library/rspec.rb

@@ -1,60 +0,0 @@
-module InfinityTest
-  module TestLibrary
-    class Rspec < TestFramework
-      binary :rspec, :name => :rspec_two
-      binary :spec,  :name => :rspec_one
-
-      parse_results :examples => /(\d+) example/, :failures => /(\d+) failure/, :pending => /(\d+) pending/
-
-      #
-      # rspec = InfinityTest::Rspec.new(:rubies => '1.9.1,1.9.2')
-      # rspec.rubies # => '1.9.1,1.9.2'
-      # rspec.test_pattern # => 'spec/**/*_spec.rb'
-      #
-      def initialize(options={})
-        super(options)
-        @test_pattern = 'spec/**/*_spec.rb'
-      end
-
-      # Construct all the commands for each ruby
-      # First, try to find the rspec one binary, and if don't have installed
-      # try to find rspec two, and raise/puts an Error if don't find it.
-      # After that, verifying if the user have a Gemfile, and if has,
-      # run with "bundle exec" command, else will run normally
-      #
-      def construct_rubies_commands(file=nil)
-        commands = {}
-        environments do |environment, ruby_version|
-          rspec_binary = search_rspec_two(environment)
-          rspec_binary = search_rspec_one(environment) unless have_binary?(rspec_binary)
-          specific_options = @specific_options[ruby_version]
-          commands[ruby_version] = construct_command(
-                                      :for => ruby_version,
-                                      :binary => rspec_binary,
-                                      :file => file,
-                                      :environment => environment,
-                                      :specific_options => specific_options)
-        end
-        commands
-      end
-
-      def search_files(file_pattern)
-        all_files.grep(/#{file_pattern}/i).join(' ')
-      end
-
-      def sucess?
-        return false if failure? or pending?
-        true
-      end
-
-      def failure?
-        @failures > 0
-      end
-
-      def pending?
-        @pending > 0 and not failure?
-      end
-
-    end
-  end
-end

data/lib/infinity_test/test_library/test_unit.rb

@@ -1,52 +0,0 @@
-module InfinityTest
-  module TestLibrary
-    class TestUnit < TestFramework
-      parse_results :tests => /(\d+) tests/, :assertions => /(\d+) assertions/,
-                    :failures => /(\d+) failures/, :errors => /(\d+) errors/
-
-      def initialize(options={})
-        super(options)
-        @test_pattern = 'test/**/*_test.rb'
-      end
-
-      def construct_rubies_commands(file=nil)
-        command = {}
-        environments do |environment, ruby_version|
-          command[ruby_version] = construct_command(
-                                  :for => ruby_version,
-                                  :load_path => 'lib:test',
-                                  :file => file,
-                                  :environment => environment,
-                                  :skip_binary? => true)
-        end
-        command
-      end
-
-      def test_files
-        super.split.unshift(test_loader).sort.join(' ')
-      end
-      
-      def decide_files(file)
-        return file if file
-        test_files
-      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 failure?
-        @failures > 0 or @errors > 0
-      end
-
-      def pending?
-        false # Don't have pending in Test::Unit right?? #doubt
-      end
-
-    end
-  end
-end

data/lib/infinity_test/test_unit_loader.rb

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

data/spec/factories/infinity_test

@@ -1,5 +0,0 @@
-#!/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

@@ -1,7 +0,0 @@
-#!/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_library/rails_spec.rb

@@ -1,140 +0,0 @@
-require 'spec_helper'
-
-module InfinityTest
-  module ApplicationLibrary
-    describe Rails do
-      let(:rails) { Rails.new }
-
-      describe '#lib_pattern' do
-
-        it { rails.lib_pattern.should == "^lib/*/(.*)\.rb" }
-
-        it "should be possible to change the library pattern" do
-          rails.lib_pattern = "^another_lib/*/(.*)\.rb"
-          rails.lib_pattern.should == "^another_lib/*/(.*)\.rb"
-        end
-
-      end
-
-      describe '#test_pattern' do
-
-        it "should return the pattern for Test::Unit" do
-          stub_application_with_test_unit
-          rails.test_pattern.should == "^test/*/(.*)_test.rb"
-        end
-
-        it "should return the pattern for Rspec " do
-          stub_application_with_rspec
-          rails.test_pattern.should == "^spec/*/(.*)_spec.rb"
-        end
-
-      end
-
-      describe '#configuration_pattern' do
-
-        it "should set to config/application.rb" do
-          rails.configuration_pattern.should ==  "^config/application.rb"
-        end
-
-        it "should possible to change the configuration_pattern" do
-          rails.configuration_pattern = "^config/environment.rb"
-          rails.configuration_pattern.should == "^config/environment.rb"
-        end
-
-      end
-
-      describe '#routes_pattern' do
-
-        it "should return the routes_pattern" do
-          rails.routes_pattern.should == "^config/routes\.rb"
-        end
-
-        it "should be possible to set the routes pattern" do
-          rails.routes_pattern = "^config/routes_s\.rb"
-          rails.routes_pattern.should == "^config/routes_s\.rb"
-        end
-
-      end
-
-      describe '#fixtures_pattern' do
-
-        it "should set the fixtures pattern" do
-          stub_application_with_test_unit
-          rails.fixtures_pattern.should == "^test/fixtures/(.*).yml"
-        end
-
-        it "should set a diferent fixtures pattern" do
-          stub_application_with_rspec
-          rails.fixtures_pattern.should == "^spec/fixtures/(.*).yml"
-        end
-
-      end
-
-      describe '#controllers_pattern' do
-
-        it "should set the controllers pattern" do
-          rails.controllers_pattern.should == "^app/controllers/(.*)\.rb"
-        end
-
-        it "should be possible to set the controllers pattern" do
-          rails.controllers_pattern = "^app/super_controllers/(.*)\.rb"
-          rails.controllers_pattern.should == "^app/super_controllers/(.*)\.rb"
-        end
-
-      end
-
-      describe '#helpers_pattern' do
-        it "should return the controllers pattern" do
-          rails.helpers_pattern.should == "^app/helpers/(.*)\.rb"
-        end
-
-        it "should be possible to set the controllers pattern" do
-          rails.helpers_pattern = "^app/super_helpers/(.*)\.rb"
-          rails.helpers_pattern.should == "^app/super_helpers/(.*)\.rb"
-        end
-      end
-
-      describe '#mailers_pattern' do
-
-        it "should return the controllers pattern" do
-          rails.mailers_pattern.should == "^app/mailers/(.*)\.rb"
-        end
-
-        it "should be possible to set the controllers pattern" do
-          rails.mailers_pattern = "^app/super_mailers/(.*)\.rb"
-          rails.mailers_pattern.should == "^app/super_mailers/(.*)\.rb"
-        end
-
-      end
-
-      describe '#application_controller_pattern' do
-        it "should return the application controller" do
-          rails.application_controller_pattern.should == "^app/controllers/application_controller.rb"
-        end
-      end
-
-      describe '#application_helper_pattern' do
-        it "should return the application_helper_pattern" do
-          rails.application_helper_pattern.should == "^app/helpers/application_helper.rb"
-        end
-        it "should be possible to set the application helper pattern" do
-          rails.application_helper_pattern = "my_pattern"
-          rails.application_helper_pattern.should == "my_pattern"
-        end
-      end
-
-      describe '#models_pattern' do
-        it "should set the controllers pattern" do
-          rails.models_pattern.should == "^app/models/(.*)\.rb"
-        end
-
-        it "should be possible to set the controllers pattern" do
-          rails.models_pattern = "^app/super_models/(.*)\.rb"
-          rails.models_pattern.should == "^app/super_models/(.*)\.rb"
-        end
-
-      end
-
-    end
-  end
-end

data/spec/infinity_test/application_library/rubygems_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-module InfinityTest
-  module ApplicationLibrary
-    describe RubyGems do
-      let(:rubygems) { RubyGems.new }
-
-      describe '#application' do
-        it { rubygems.application.should equal InfinityTest.application }
-      end
-
-      describe '#lib_pattern' do
-
-        it { rubygems.lib_pattern.should == "^lib/*/(.*)\.rb" }
-
-        it "should be possible to change the library pattern" do
-          rubygems.lib_pattern = "^another_lib/*/(.*)\.rb"
-          rubygems.lib_pattern.should == "^another_lib/*/(.*)\.rb"
-        end
-
-      end
-
-      describe '#test_pattern' do
-
-        it "should return the pattern for Test::Unit" do
-          stub_application_with_test_unit
-          rubygems.test_pattern.should == "^test/*/(.*)_test.rb"
-        end
-
-        it "should return the pattern for Rspec" do
-          stub_application_with_rspec
-          rubygems.test_pattern.should == "^spec/*/(.*)_spec.rb"
-        end
-
-      end
-
-      describe '#test_helper_pattern' do
-        it "should return the pattern for Test::Unit" do
-          stub_application_with_test_unit
-          rubygems.test_helper_pattern.should == "^test/*/test_helper.rb"
-        end
-
-        it "should return the pattern for Rspec" do
-          stub_application_with_rspec
-          rubygems.test_helper_pattern.should == "^spec/*/spec_helper.rb"
-        end
-
-      end
-
-    end
-  end
-end