infinity_test 1.0.3 → 2.0.0.rc2

data/lib/infinity_test.rb

@@ -1,51 +1,82 @@
-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/strategy/elixir_default'
+require 'infinity_test/strategy/python_default'
+require 'infinity_test/strategy/rust_default'
+require 'infinity_test/framework/padrino'
+require 'infinity_test/framework/rails'
+require 'infinity_test/framework/rubygems'
+require 'infinity_test/framework/elixir_mix'
+require 'infinity_test/framework/phoenix'
+require 'infinity_test/framework/python_package'
+require 'infinity_test/framework/fast_api'
+require 'infinity_test/framework/django'
+require 'infinity_test/framework/rust_cargo'
+require 'infinity_test/framework/rocket'
+require 'infinity_test/test_framework/test_unit'
+require 'infinity_test/test_framework/rspec'
+require 'infinity_test/test_framework/ex_unit'
+require 'infinity_test/test_framework/pytest'
+require 'infinity_test/test_framework/cargo_test'

data/spec/infinity_test/core/auto_discover_spec.rb

@@ -0,0 +1,175 @@
+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)
+          allow(Strategy::ElixirDefault).to receive(:run?).and_return(false)
+          allow(Strategy::PythonDefault).to receive(:run?).and_return(false)
+          allow(Strategy::RustDefault).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)
+          allow(Strategy::ElixirDefault).to receive(:run?).and_return(false)
+          allow(Strategy::PythonDefault).to receive(:run?).and_return(false)
+          allow(Strategy::RustDefault).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)
+          allow(Framework::ElixirMix).to receive(:run?).and_return(false)
+          allow(Framework::Phoenix).to receive(:run?).and_return(false)
+          allow(Framework::Django).to receive(:run?).and_return(false)
+          allow(Framework::FastApi).to receive(:run?).and_return(false)
+          allow(Framework::PythonPackage).to receive(:run?).and_return(false)
+          allow(Framework::Rocket).to receive(:run?).and_return(false)
+          allow(Framework::RustCargo).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)
+          allow(TestFramework::ExUnit).to receive(:run?).and_return(false)
+          allow(TestFramework::Pytest).to receive(:run?).and_return(false)
+          allow(TestFramework::CargoTest).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, :elixir_default, :python_default, :rust_default, :ruby_default]
+      end
+
+      it 'defines priority order for frameworks' do
+        expect(AutoDiscover::PRIORITY[:framework]).to eq [:rails, :padrino, :phoenix, :elixir_mix, :django, :fast_api, :python_package, :rocket, :rust_cargo, :rubygems]
+      end
+
+      it 'defines priority order for test frameworks' do
+        expect(AutoDiscover::PRIORITY[:test_framework]).to eq [:rspec, :test_unit, :ex_unit, :pytest, :cargo_test]
+      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::ElixirDefault).to receive(:run?).and_return(false)
+          allow(Strategy::PythonDefault).to receive(:run?).and_return(false)
+          allow(Strategy::RustDefault).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::Phoenix).to receive(:run?).and_return(false)
+          allow(Framework::ElixirMix).to receive(:run?).and_return(false)
+          allow(Framework::Django).to receive(:run?).and_return(false)
+          allow(Framework::FastApi).to receive(:run?).and_return(false)
+          allow(Framework::PythonPackage).to receive(:run?).and_return(false)
+          allow(Framework::Rocket).to receive(:run?).and_return(false)
+          allow(Framework::RustCargo).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

data/spec/infinity_test/core/base_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+module InfinityTest
+  describe Base do
+    describe ".setup" do
+      it "yields self" do
+        Base.setup do |config|
+          expect(config).to be InfinityTest::Base
+        end
+      end
+    end
+
+    describe ".using_bundler?" do
+      it "returns the same bundler accessor" do
+        expect(Base.using_bundler?).to equal Base.bundler
+      end
+    end
+
+    describe "#verbose?" do
+      it "returns the same verbose accessor" do
+        expect(Base.verbose?).to equal Base.verbose
+      end
+    end
+
+    describe ".observer" do
+      it "has listen as default observer" do
+        expect(Base.observer).to equal :listen
+      end
+    end
+
+    describe ".ignore_test_files" do
+      it "does not have test files to ignore as default" do
+        expect(Base.ignore_test_files).to eql []
+      end
+    end
+
+    describe "#ignore_test_folders" do
+      it "does not ignore test folders as default" do
+        expect(Base.ignore_test_folders).to eql []
+      end
+    end
+
+    describe ".before" do
+      after { Base.clear_callbacks! }
+
+      it "creates before callback instance and pushes to the callback accessor" do
+        before_callback = Base.before(:all) { 'To Infinity and beyond!' }
+        expect(before_callback).to be_a Core::Callback
+        expect(before_callback.type).to eq :before
+        expect(before_callback.scope).to eq :all
+        expect(Base.callbacks).to include before_callback
+      end
+
+      it "defaults scope to :all" do
+        before_callback = Base.before { 'test' }
+        expect(before_callback.scope).to eq :all
+      end
+    end
+
+    describe ".after" do
+      after { Base.clear_callbacks! }
+
+      it "creates after callback instance and pushes to the callback accessor" do
+        after_callback = Base.after(:each_ruby) { 'done' }
+        expect(after_callback).to be_a Core::Callback
+        expect(after_callback.type).to eq :after
+        expect(after_callback.scope).to eq :each_ruby
+        expect(Base.callbacks).to include after_callback
+      end
+    end
+
+    describe ".run_before_callbacks" do
+      after { Base.clear_callbacks! }
+
+      it "runs all before callbacks for the given scope" do
+        results = []
+        Base.before(:all) { results << 'first' }
+        Base.before(:all) { results << 'second' }
+        Base.before(:each_ruby) { results << 'each_ruby' }
+
+        Base.run_before_callbacks(:all)
+        expect(results).to eq ['first', 'second']
+      end
+    end
+
+    describe ".run_after_callbacks" do
+      after { Base.clear_callbacks! }
+
+      it "runs all after callbacks for the given scope" do
+        results = []
+        Base.after(:all) { results << 'first' }
+        Base.after(:all) { results << 'second' }
+
+        Base.run_after_callbacks(:all)
+        expect(results).to eq ['first', 'second']
+      end
+    end
+
+    describe ".just_watch" do
+      it "defaults to false" do
+        expect(Base.just_watch).to eq false
+      end
+    end
+
+    describe ".notifications" do
+      it "sets the notification class accessor" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript)
+          expect(Base.notifications).to be :osascript
+        end
+      end
+
+      it "sets the images" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript) do
+            show_images :success_image => 'foo', :failure_image => 'bar', :pending_image => 'baz'
+          end
+        end
+        expect(Base.success_image).to eql 'foo'
+        expect(Base.failure_image).to eql 'bar'
+        expect(Base.pending_image).to eql 'baz'
+        Base.success_image = nil
+        Base.failure_image = nil
+        Base.pending_image = nil
+      end
+
+      it "sets the mode" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript) do
+            show_images :mode => :mortal_kombat
+          end
+        end
+        expect(Base.mode).to be :mortal_kombat
+      end
+    end
+
+    describe ".use" do
+      before do
+        @old_rubies = Base.rubies
+        @old_specific_options = Base.specific_options
+        @test_framework = Base.test_framework
+        @framework = Base.framework
+        @verbose = Base.verbose
+        @gemset  = Base.gemset
+      end
+
+      after do
+        Base.rubies = @old_rubies
+        Base.specific_options = @old_specific_options
+        Base.test_framework = @test_framework
+        Base.framework = @framework
+        Base.verbose = @verbose
+        Base.gemset = @gemset
+      end
+
+      it "sets the rubies" do
+        silence_stream(STDOUT) do
+          Base.use :rubies => %w(foo bar)
+        end
+        expect(Base.rubies).to eql %w(foo bar)
+      end
+
+      it "sets the specific options" do
+        silence_stream(STDOUT) do
+          Base.use :specific_options => '-J -Ilib -Itest'
+        end
+        expect(Base.specific_options).to eql '-J -Ilib -Itest'
+      end
+
+      it "sets the test framework" do
+        silence_stream(STDOUT) do
+          Base.use :test_framework => :rspec
+        end
+        expect(Base.test_framework).to be :rspec
+      end
+
+      it "sets the app framework" do
+        silence_stream(STDOUT) do
+          Base.use :app_framework => :rails
+        end
+        expect(Base.framework).to be :rails
+      end
+
+      it "sets the verbose mode" do
+        silence_stream(STDOUT) do
+          Base.use :verbose => false
+        end
+        expect(Base.verbose).to equal false
+      end
+
+      it "sets the gemset" do
+        silence_stream(STDOUT) do
+          Base.use :gemset => 'infinity_test'
+        end
+        expect(Base.gemset).to eql 'infinity_test'
+      end
+    end
+
+    describe ".heuristics" do
+      it "accepts a block" do
+        expect { Base.heuristics {} }.to_not raise_exception
+      end
+    end
+
+    describe ".replace_patterns" do
+      it "accepts a block" do
+        expect { Base.replace_patterns {} }.to_not raise_exception
+      end
+    end
+
+    describe ".merge!" do
+      let(:options) { Object.new }
+      let(:configuration_merge) { Object.new }
+
+      it "calls merge on the configuration merge object" do
+        expect(ConfigurationMerge).to receive(:new).with(Core::Base, options).and_return(configuration_merge)
+        expect(configuration_merge).to receive(:merge!)
+        Core::Base.merge!(options)
+      end
+    end
+
+    describe ".clear" do
+      it "calls clear_terminal method" do
+        silence_stream(STDOUT) do
+          expect(Base).to receive(:clear_terminal).and_return(true)
+          Base.clear(:terminal)
+        end
+      end
+    end
+
+    describe ".clear_terminal" do
+      it "calls system clear" do
+        silence_stream(STDOUT) do
+          expect(Base).to receive(:system).with('clear').and_return(true)
+          Base.clear_terminal
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/callback_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe Callback do
+      describe '#initialize' do
+        it 'creates a before callback with default scope' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback.type).to eq :before
+          expect(callback.scope).to eq :all
+        end
+
+        it 'creates an after callback with custom scope' do
+          callback = Callback.new(:after, :each_ruby) { 'test' }
+          expect(callback.type).to eq :after
+          expect(callback.scope).to eq :each_ruby
+        end
+
+        it 'raises error for invalid scope' do
+          expect { Callback.new(:before, :invalid) { 'test' } }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#call' do
+        it 'executes the block without arguments' do
+          result = nil
+          callback = Callback.new(:before) { result = 'executed' }
+          callback.call
+          expect(result).to eq 'executed'
+        end
+
+        it 'executes the block with environment argument' do
+          result = nil
+          callback = Callback.new(:before, :each_ruby) { |env| result = env[:ruby_version] }
+          callback.call(ruby_version: '3.0.0')
+          expect(result).to eq '3.0.0'
+        end
+      end
+
+      describe '#before?' do
+        it 'returns true for before callbacks' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback).to be_before
+        end
+
+        it 'returns false for after callbacks' do
+          callback = Callback.new(:after) { 'test' }
+          expect(callback).not_to be_before
+        end
+      end
+
+      describe '#after?' do
+        it 'returns true for after callbacks' do
+          callback = Callback.new(:after) { 'test' }
+          expect(callback).to be_after
+        end
+
+        it 'returns false for before callbacks' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback).not_to be_after
+        end
+      end
+
+      describe '#all?' do
+        it 'returns true for all scope' do
+          callback = Callback.new(:before, :all) { 'test' }
+          expect(callback).to be_all
+        end
+
+        it 'returns false for each_ruby scope' do
+          callback = Callback.new(:before, :each_ruby) { 'test' }
+          expect(callback).not_to be_all
+        end
+      end
+
+      describe '#each_ruby?' do
+        it 'returns true for each_ruby scope' do
+          callback = Callback.new(:before, :each_ruby) { 'test' }
+          expect(callback).to be_each_ruby
+        end
+
+        it 'returns false for all scope' do
+          callback = Callback.new(:before, :all) { 'test' }
+          expect(callback).not_to be_each_ruby
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/changed_file_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module InfinityTest
+  describe ChangedFile do
+    let(:match_data) { /(.)(.)(\d+)(\d)/.match("THX1138.") }
+    let(:changed_file) { ChangedFile.new(match_data) }
+
+    describe '#name' do
+      subject { changed_file.name }
+
+      it { should eq 'HX1138' }
+    end
+
+    describe '#path' do
+      subject { changed_file.path }
+
+      it { should eq 'H' }
+    end
+
+    describe '#match_data' do
+      subject { changed_file.match_data }
+
+      it { should be match_data }
+    end
+  end
+end

data/spec/infinity_test/core/command_builder_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe CommandBuilder do
+      describe "#add" do
+        it "adds the argument in the command" do
+          expect(subject.ruby.option(:S).add(:rspec).add(:spec)).to eq 'ruby -S rspec spec'
+        end
+      end
+
+      describe "#option" do
+        it "puts options with one dash and allows adding more keywords" do
+          expect(subject.bundle.exec.ruby.option(:S).rspec).to eq 'bundle exec ruby -S rspec'
+        end
+      end
+
+      describe "#opt" do
+        it "puts double dash options and allows adding keywords" do
+          expect(subject.ruby.opt(:copyright)).to eq 'ruby --copyright'
+        end
+      end
+
+      describe '#method_missing' do
+        it "puts space after every keyword" do
+          expect(subject.bundle.exec.ruby.some_file).to eq 'bundle exec ruby some_file'
+        end
+      end
+
+      describe "#respond_to?" do
+        it "responds to anything because missing methods will build the command" do
+          expect(subject.respond_to?(:foo)).to be true
+          expect(subject.respond_to?(:bar)).to be true
+        end
+      end
+    end
+  end
+end