infinity_test 1.0.2 → 2.0.0.rc1

data/lib/infinity_test/old_dsl/configuration.rb

@@ -0,0 +1,26 @@
+module InfinityTest
+  module OldDSL
+    class Configuration
+      # Pass the responsability to InfinityTest::Base class.
+      #
+      # <b>Don't need #super or #respond_to here.</b>
+      # <b>This class will be removed in infinity_test 2.0.1</b>
+      #
+      def method_missing(method_name, *arguments, &block)
+        InfinityTest::Base.send(method_name, *arguments, &block)
+      end
+    end
+
+    module InfinityTestMethod
+      # <b>DEPRECATED:</b> Please use <tt>InfinityTest::Base.setup</tt> instead.
+      #
+      def infinity_test(&block)
+        message = "infinity_test method is deprecated. Use InfinityTest.setup { |config| ... } instead."
+        ActiveSupport::Deprecation.warn(message)
+        ::InfinityTest::OldDSL::Configuration.new.instance_eval(&block)
+      end
+    end
+  end
+end
+
+include InfinityTest::OldDSL::InfinityTestMethod

data/lib/infinity_test/strategy/base.rb

@@ -0,0 +1,34 @@
+module InfinityTest
+  module Strategy
+    class Base
+      def initialize(continuous_test_server)
+        @continuous_test_server = continuous_test_server
+      end
+
+      # ==== Returns
+      # CommandBuilderClass: A class that builds that command using method_missing.
+      #
+      def command_builder
+        Core::CommandBuilder.new
+      end
+
+      # Run the strategy and parse the results storing in the strategy.
+      #
+      def run
+        Core::CommandRunner.new(run!)
+      end
+
+      # Implement #run! method returning a string command to be run.
+      #
+      def run!
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      # Put all the requires to autodiscover use your strategy instead of others.
+      #
+      def self.run?
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+    end
+  end
+end

data/lib/infinity_test/strategy/rbenv.rb

@@ -0,0 +1,32 @@
+module InfinityTest
+  module Strategy
+    class Rbenv < Base
+      attr_reader :continuous_test_server
+      delegate :binary, :test_files, to: :continuous_test_server
+
+      # Build and run commands for each ruby version specified.
+      # Uses rbenv's RBENV_VERSION environment variable to run tests in different Ruby environments.
+      #
+      # ==== Returns
+      #  String: The command string for all ruby versions joined with &&
+      #
+      def run!
+        rubies = Core::Base.rubies
+
+        commands = rubies.map do |ruby_version|
+          "RBENV_VERSION=#{ruby_version} #{command_builder.ruby.option(:S).add(binary).add(test_files).to_s}"
+        end
+
+        commands.join(' && ')
+      end
+
+      # ==== Returns
+      #  TrueClass:  If the user has rbenv installed AND has specified rubies to test against.
+      #  FalseClass: If rbenv is not installed OR no rubies are specified.
+      #
+      def self.run?
+        Core::Base.rubies.present? && File.exist?(File.expand_path('~/.rbenv'))
+      end
+    end
+  end
+end

data/lib/infinity_test/strategy/ruby_default.rb

@@ -0,0 +1,20 @@
+module InfinityTest
+  module Strategy
+    class RubyDefault < Base
+      attr_reader :continuous_test_server
+      delegate :binary, :test_files, to: :continuous_test_server
+
+      def run!
+        command_builder.ruby.option(:S).add(binary).add(test_files).to_s
+      end
+
+      # ==== Returns
+      #  TrueClass: If the user don't pass the ruby versions to run tests.
+      #  FalseClass: If the user pass some ruby version to run tests.
+      #
+      def self.run?
+        Core::Base.rubies.blank?
+      end
+    end
+  end
+end

data/lib/infinity_test/strategy/rvm.rb

@@ -0,0 +1,50 @@
+module InfinityTest
+  module Strategy
+    class Rvm < Base
+      attr_reader :continuous_test_server
+      delegate :binary, :test_files, to: :continuous_test_server
+
+      # Build and run commands for each ruby version specified.
+      # Uses RVM's `rvm <version> do` syntax to run tests in different Ruby environments.
+      #
+      # ==== Returns
+      #  String: The command string for the first ruby version (others run sequentially)
+      #
+      def run!
+        rubies = Core::Base.rubies
+        gemset = Core::Base.gemset
+
+        commands = rubies.map do |ruby_version|
+          ruby_with_gemset = gemset.present? ? "#{ruby_version}@#{gemset}" : ruby_version
+          command_builder.rvm.add(ruby_with_gemset).do.ruby.option(:S).add(binary).add(test_files).to_s
+        end
+
+        commands.join(' && ')
+      end
+
+      # ==== Returns
+      #  TrueClass: If the user has RVM installed AND has specified rubies to test against.
+      #  FalseClass: If RVM is not installed OR no rubies are specified.
+      #
+      def self.run?
+        Core::Base.rubies.present? && (installed_users_home? || installed_system_wide?)
+      end
+
+      # ==== Returns
+      #  TrueClass: Find rvm installed in ~/.rvm.
+      #  FalseClass: Don't Find rvm installed in ~/.rvm.
+      #
+      def self.installed_users_home?
+        File.exist?(File.expand_path('~/.rvm'))
+      end
+
+      # ==== Returns
+      #  TrueClass: Find rvm installed in /usr/local/rvm.
+      #  FalseClass: Don't Find rvm installed in /usr/local/rvm.
+      #
+      def self.installed_system_wide?
+        File.exist?(File.expand_path("/usr/local/rvm"))
+      end
+    end
+  end
+end

data/lib/infinity_test/strategy/shared_example.rb

@@ -0,0 +1,32 @@
+module InfinityTest
+  module Strategy
+    module SharedExample
+      # Shared Examples to use in the RSpec specs when you want create your own strategy
+      #
+      # ==== Examples
+      #
+      #   RSpec.configure do |config|
+      #     config.include InfinityTest::Strategy::SharedExample
+      #   end
+      #
+      #   describe FooStrategy do
+      #     subject { FooStrategy.new(InfinityTest::Core::Base) }
+      #     it_should_behave_like 'a infinity test strategy'
+      #   end
+      #
+      shared_examples_for 'a infinity test strategy' do
+        it 'responds to #run!' do
+          expect(subject).to respond_to(:run)
+        end
+
+        it 'responds to .run?' do
+          expect(subject.class).to respond_to(:run?)
+        end
+
+        it 'has Strategy::Base as superclass' do
+          expect(subject.class.superclass).to be InfinityTest::Strategy::Base
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/test_framework/base.rb

@@ -0,0 +1,64 @@
+module InfinityTest
+  module TestFramework
+    class Base
+      attr_writer :test_files
+      attr_reader :test_message
+
+      def test_helper_file
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def test_dir
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def test_dir=(dir)
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def binary
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      # Parse the test results based by the framework patterns.
+      # <b>The subclass must implement the #patterns method.</b>
+      #
+      def test_message=(message)
+        @test_message = final_results(message).join.gsub(/\e\[\d+?m/, '') # Clean ANSIColor strings
+
+        patterns.each do |key, pattern|
+          spec_number = test_message[pattern, 1].to_i
+          instance_variable_set("@#{key}", spec_number)
+        end
+
+        @test_message
+      end
+
+      def patterns
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def success?
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def failure?
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def pending?
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      private
+
+      def final_results(message)
+        lines    = message.split("\n")
+
+        patterns.map do |pattern_name, pattern|
+          lines.find { |line| line =~ pattern }
+        end.flatten.uniq
+      end
+    end
+  end
+end

data/lib/infinity_test/test_framework/rspec.rb

@@ -0,0 +1,48 @@
+module InfinityTest
+  module TestFramework
+    class Rspec < Base
+      def binary
+        'rspec'
+      end
+
+      def test_helper_file
+        File.join(test_dir, 'spec_helper.rb')
+      end
+
+      def test_dir
+        @test_dir ||= 'spec'
+      end
+
+      def test_dir=(dir)
+        @test_dir = dir
+      end
+
+      def test_files
+        @test_files || test_dir
+      end
+
+      def patterns
+        { :examples => /(\d+) example/, :failures => /(\d+) failure/, :pending => /(\d+) pending/ }
+      end
+
+      def success?
+        @failures.zero? and @pending.zero?
+      end
+
+      def failure?
+        @failures > 0
+      end
+
+      def pending?
+        @pending > 0
+      end
+
+      def self.run?
+        File.exist?('spec') && (
+          File.exist?('spec/spec_helper.rb') ||
+          Dir['spec/**/*_spec.rb'].any?
+        )
+      end
+    end
+  end
+end

data/lib/infinity_test/test_framework/shared_example.rb

@@ -0,0 +1,56 @@
+module InfinityTest
+  module TestFramework
+    module SharedExample
+      # Shared Examples to use in the RSpec specs when you want create your own infinity test wrapper test framework
+      #
+      # ==== Examples
+      #
+      #   RSpec.configure do |config|
+      #     config.include InfinityTest::TestFramework::SharedExample
+      #   end
+      #
+      #   describe FooTestFramework do
+      #     subject { FooStrategy.new(InfinityTest::Core::Base) }
+      #     it_should_behave_like 'a infinity test test framework'
+      #   end
+      #
+      shared_examples_for 'a infinity test test framework' do
+        it 'responds to #test_message=' do
+          expect(subject).to respond_to(:test_message=)
+        end
+
+        it 'responds to #test_message' do
+          expect(subject).to respond_to(:test_message)
+        end
+
+        it 'responds to #succeed?' do
+          expect(subject).to respond_to(:success?)
+        end
+
+        it 'responds to #failure?' do
+          expect(subject).to respond_to(:failure?)
+        end
+
+        it 'responds to #pending?' do
+          expect(subject).to respond_to(:pending?)
+        end
+
+        it 'responds to #test_helper_file' do
+          expect(subject).to respond_to(:test_helper_file)
+        end
+
+        it 'responds to #test_dir' do
+          expect(subject).to respond_to(:test_dir)
+        end
+
+        it 'responds to #test_dir=' do
+          expect(subject).to respond_to(:test_dir=)
+        end
+
+        it 'responds to #binary' do
+          expect(subject).to respond_to(:binary)
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/test_framework/test_unit.rb

@@ -0,0 +1,57 @@
+module InfinityTest
+  module TestFramework
+    class TestUnit < Base
+      def test_dir
+        @test_dir ||= 'test'
+      end
+
+      def test_dir=(dir)
+        @test_dir = dir
+      end
+
+      def test_helper_file
+        File.join(test_dir, 'test_helper.rb')
+      end
+
+      def test_files
+        @test_files || test_dir
+      end
+
+      def binary
+        'ruby'
+      end
+
+      # Patterns for parsing minitest/test-unit output
+      # Example: "10 runs, 15 assertions, 0 failures, 0 errors, 0 skips"
+      def patterns
+        {
+          :runs => /(\d+) runs,/,
+          :assertions => /(\d+) assertions,/,
+          :failures => /(\d+) failures,/,
+          :errors => /(\d+) errors,/,
+          :skips => /(\d+) skips/
+        }
+      end
+
+      def success?
+        @failures.zero? && @errors.zero? && @skips.zero?
+      end
+
+      def failure?
+        @failures > 0 || @errors > 0
+      end
+
+      def pending?
+        @skips > 0
+      end
+
+      def self.run?
+        File.exist?('test') && (
+          File.exist?('test/test_helper.rb') ||
+          Dir['test/**/*_test.rb'].any? ||
+          Dir['test/**/test_*.rb'].any?
+        )
+      end
+    end
+  end
+end

data/lib/infinity_test.rb

@@ -1,51 +1,69 @@
-require 'infinity_test/dependencies'
+require 'optparse'
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/deprecation'
+require 'hike'
+require 'notifiers'
 
 module InfinityTest
-  
-  autoload :Application, 'infinity_test/application'
-  autoload :BinaryPath, 'infinity_test/binary_path'
-  autoload :Builder, 'infinity_test/builder'
-  autoload :Command, 'infinity_test/command'
-  autoload :Configuration, 'infinity_test/configuration'
-  autoload :ContinuousTesting, 'infinity_test/continuous_testing'
-  autoload :Environment, 'infinity_test/environment'
-  autoload :Heuristics, 'infinity_test/heuristics'
-  autoload :HeuristicsHelper, 'infinity_test/heuristics_helper'
-  autoload :Options, 'infinity_test/options'
-  autoload :Runner, 'infinity_test/runner'
-  autoload :TestFramework, 'infinity_test/test_framework'
-
-  module ApplicationLibrary
-    autoload :Rails , 'infinity_test/application_library/rails'
-    autoload :RubyGems, 'infinity_test/application_library/rubygems'
+  module Core
+    autoload :AutoDiscover, 'infinity_test/core/auto_discover'
+    autoload :Base, 'infinity_test/core/base'
+    autoload :Callback, 'infinity_test/core/callback'
+    autoload :CommandBuilder, 'infinity_test/core/command_builder'
+    autoload :CommandRunner,  'infinity_test/core/command_runner'
+    autoload :ConfigurationMerge, 'infinity_test/core/configuration_merge'
+    autoload :ContinuousTestServer, 'infinity_test/core/continuous_test_server'
+    autoload :ChangedFile, 'infinity_test/core/changed_file'
+    autoload :LoadConfiguration, 'infinity_test/core/load_configuration'
+    autoload :Notifier, 'infinity_test/core/notifier'
+    autoload :Options, 'infinity_test/core/options'
+    autoload :Runner, 'infinity_test/core/runner'
   end
 
-  module TestLibrary
-    autoload :Bacon, 'infinity_test/test_library/bacon'
-    autoload :Cucumber, 'infinity_test/test_library/cucumber'
-    autoload :Rspec, 'infinity_test/test_library/rspec'
-    autoload :TestUnit, 'infinity_test/test_library/test_unit'
+  # This will be removed in the InfinityTest oficial 2.0.1.
+  #
+  module OldDSL
+    autoload :Configuration, 'infinity_test/old_dsl/configuration'
   end
 
-  def self.application
-    @application ||= Application.new
+  module Framework
+    autoload :Base, 'infinity_test/framework/base'
+    autoload :Helpers, 'infinity_test/framework/helpers'
+    autoload :SharedExample, 'infinity_test/framework/shared_example'
   end
 
-  def self.configuration
-    @configuration ||= Configuration.new
+  module Observer
+    autoload :Base, 'infinity_test/observer/base'
+    autoload :Listen, 'infinity_test/observer/listen'
+    autoload :Filewatcher, 'infinity_test/observer/filewatcher'
+    autoload :SharedExample, 'infinity_test/observer/shared_example'
   end
 
-  def self.watchr
-    @watchr ||= Watchr::Script.new
+  module Strategy
+    autoload :Base, 'infinity_test/strategy/base'
+    autoload :SharedExample, 'infinity_test/strategy/shared_example'
   end
 
-  def self.start!
-    Runner.new(ARGV).run!
+  module TestFramework
+    autoload :Base, 'infinity_test/test_framework/base'
+    autoload :SharedExample, 'infinity_test/test_framework/shared_example'
   end
-  
-  def self.version
-    version = YAML.load_file(File.dirname(__FILE__) + '/../VERSION.yml')
-    [version[:major], version[:minor], version[:patch]].compact.join(".")    
+
+  # See Core::Base.setup to more information.
+  #
+  def self.setup(&block)
+    InfinityTest::Base.setup(&block)
   end
 
+  include Core
 end
+
+require 'infinity_test/strategy/rbenv'
+require 'infinity_test/strategy/rvm'
+require 'infinity_test/strategy/ruby_default'
+require 'infinity_test/framework/padrino'
+require 'infinity_test/framework/rails'
+require 'infinity_test/framework/rubygems'
+require 'infinity_test/test_framework/test_unit'
+require 'infinity_test/test_framework/rspec'

data/spec/infinity_test/core/auto_discover_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+
+module InfinityTest
+  describe AutoDiscover do
+    let(:base) { BaseFixture.new }
+    let(:auto_discover) { AutoDiscover.new(base) }
+
+    describe '#discover_libraries' do
+      it 'discovers strategy, framework and test framework' do
+        expect(auto_discover).to receive(:discover_strategy)
+        expect(auto_discover).to receive(:discover_framework)
+        expect(auto_discover).to receive(:discover_test_framework)
+        auto_discover.discover_libraries
+      end
+    end
+
+    describe '#discover_strategy' do
+      context 'when strategy is auto discover' do
+        before do
+          base.strategy = :auto_discover
+          allow(Strategy::RubyDefault).to receive(:run?).and_return(false)
+          expect(Strategy::Rvm).to receive(:run?).and_return(true)
+        end
+
+        it 'changes the base strategy' do
+          auto_discover.discover_strategy
+          expect(base.strategy).to be :rvm
+        end
+      end
+
+      context 'when strategy is different from auto discover' do
+        before { base.strategy = :ruby_default }
+
+        it 'does not change anything' do
+          auto_discover.discover_strategy
+          expect(base.strategy).to be :ruby_default
+        end
+      end
+
+      context 'when do not find any strategy' do
+        before do
+          base.strategy = :auto_discover
+          allow(Strategy::RubyDefault).to receive(:run?).and_return(false)
+          expect(Strategy::Rvm).to receive(:run?).and_return(false)
+          allow(Strategy::Rbenv).to receive(:run?).and_return(false)
+        end
+
+        it 'raises exception' do
+          expect { auto_discover.discover_strategy }.to raise_error(Exception)
+        end
+      end
+    end
+
+    describe '#discover_framework' do
+      context 'when framework is auto discover' do
+        before do
+          base.framework = :auto_discover
+          allow(Framework::Rubygems).to receive(:run?).and_return(false)
+          expect(Framework::Rails).to receive(:run?).and_return(true)
+        end
+
+        it 'changes the base framework' do
+          auto_discover.discover_framework
+          expect(base.framework).to be :rails
+        end
+      end
+
+      context 'when framework is different from auto discover' do
+        before { base.framework = :padrino }
+
+        it 'does not change anything' do
+          auto_discover.discover_framework
+          expect(base.framework).to be :padrino
+        end
+      end
+    end
+
+    describe '#discover_test_framework' do
+      context 'when framework is auto discover' do
+        before do
+          base.test_framework = :auto_discover
+          allow(TestFramework::TestUnit).to receive(:run?).and_return(false)
+          expect(TestFramework::Rspec).to receive(:run?).and_return(true)
+        end
+
+        it 'changes the base framework' do
+          auto_discover.discover_test_framework
+          expect(base.test_framework).to be :rspec
+        end
+      end
+
+      context 'when framework is different from auto discover' do
+        before { base.test_framework = :test_unit }
+
+        it 'does not change anything' do
+          auto_discover.discover_test_framework
+          expect(base.test_framework).to be :test_unit
+        end
+      end
+    end
+
+    describe 'PRIORITY' do
+      it 'defines priority order for strategies' do
+        expect(AutoDiscover::PRIORITY[:strategy]).to eq [:rvm, :rbenv, :ruby_default]
+      end
+
+      it 'defines priority order for frameworks' do
+        expect(AutoDiscover::PRIORITY[:framework]).to eq [:rails, :padrino, :rubygems]
+      end
+
+      it 'defines priority order for test frameworks' do
+        expect(AutoDiscover::PRIORITY[:test_framework]).to eq [:rspec, :test_unit]
+      end
+    end
+
+    describe 'priority ordering' do
+      context 'when multiple strategies match' do
+        before do
+          base.strategy = :auto_discover
+          # Both RVM and RubyDefault would match, but RVM has higher priority
+          allow(Strategy::Rvm).to receive(:run?).and_return(true)
+          allow(Strategy::Rbenv).to receive(:run?).and_return(false)
+          allow(Strategy::RubyDefault).to receive(:run?).and_return(true)
+        end
+
+        it 'selects the higher priority strategy (RVM over RubyDefault)' do
+          auto_discover.discover_strategy
+          expect(base.strategy).to be :rvm
+        end
+      end
+
+      context 'when multiple frameworks match' do
+        before do
+          base.framework = :auto_discover
+          # Both Rails and Rubygems would match, but Rails has higher priority
+          allow(Framework::Rails).to receive(:run?).and_return(true)
+          allow(Framework::Padrino).to receive(:run?).and_return(false)
+          allow(Framework::Rubygems).to receive(:run?).and_return(true)
+        end
+
+        it 'selects the higher priority framework (Rails over Rubygems)' do
+          auto_discover.discover_framework
+          expect(base.framework).to be :rails
+        end
+      end
+    end
+  end
+end