infinity_test 1.0.3 → 2.0.0.rc1

data/lib/infinity_test/core/load_configuration.rb

@@ -0,0 +1,48 @@
+module InfinityTest
+  module Core
+    class LoadConfiguration
+      attr_accessor :global_file, :project_file
+
+      def initialize
+        @global_file  = File.expand_path('~/INFINITY_TEST')
+        @project_file = './INFINITY_TEST'
+        @old_configuration = InfinityTest::OldDSL::Configuration
+      end
+
+      # Load the Configuration file
+      #
+      # Command line options can be persisted in an INFINITY_TEST file in a project.
+      # You can also store an INFINITY_TEST file in your home directory (~/INFINITY_TEST)
+      #
+      # Precedence is:
+      # command line
+      # ./INFINITY_TEST
+      # ~/INFINITY_TEST
+      #
+      # Example:
+      #
+      #  ~/INFINITY_TEST -> infinity_test { notifications :osascript }
+      #
+      #  ./INFINITY_TEST -> infinity_test { notifications :terminal_notifier } # High Priority
+      #
+      # After the load the Notifications Framework will be Terminal Notifier
+      #
+      def load!
+        load_global_file!
+        load_project_file!
+      end
+
+      def load_global_file!
+        load_file(@global_file)
+      end
+
+      def load_project_file!
+        load_file(@project_file)
+      end
+
+      def load_file(file)
+        load(file) if File.exist?(file)
+      end
+    end
+  end
+end

data/lib/infinity_test/core/notifier.rb

@@ -0,0 +1,59 @@
+module InfinityTest
+  module Core
+    class Notifier
+      include ::Notifiers
+
+      attr_reader :test_framework, :library
+
+      IMAGES = File.expand_path(File.join(File.dirname(__FILE__), '..', '..', '..', 'images'))
+
+      delegate :test_message, to: :test_framework
+
+      def initialize(options)
+        @test_framework = options.fetch(:test_framework)
+        @library        = options.fetch(:library)
+      end
+
+      def notify
+        send(library).title(RUBY_VERSION).message(test_message).image(image).notify
+      end
+
+      def image
+        return success_image if test_framework.success?
+
+        if test_framework.failure?
+          failure_image
+        else
+          pending_image
+        end
+      end
+
+      def success_image
+        Core::Base.success_image || find_image(:success)
+      end
+
+      def failure_image
+        Core::Base.failure_image || find_image(:failure)
+      end
+
+      def pending_image
+        Core::Base.pending_image || find_image(:pending)
+      end
+
+      def find_image(image_type)
+        Dir.glob(File.join(images_dir, "#{image_type.to_s}*")).first
+      end
+
+      def images_dir
+        mode = Core::Base.mode
+
+        case mode
+        when Symbol
+          File.join(IMAGES, mode.to_s)
+        when String
+          File.expand_path(File.join(mode))
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/core/options.rb

@@ -0,0 +1,134 @@
+module InfinityTest
+  module Core
+    class Options
+      attr_accessor :arguments, :options_parser, :strategy, :bundler, :verbose
+      attr_accessor :rubies, :specific_options, :test_framework, :framework, :infinity_and_beyond
+      attr_accessor :notifications, :mode, :just_watch, :focus
+
+      def initialize(*arguments)
+        @arguments = arguments.flatten.clone
+        @options_parser = new_options_parser
+      end
+
+      def new_options_parser
+        OptionParser.new do |option|
+          %w(
+            ruby_strategy
+            ruby_versions
+            options_to_added_in_the_command
+            test_framework_to_be_run
+            app_framework
+            notifications_library
+            image_mode
+            infinity_and_beyond_option
+            just_watch_option
+            focus_option
+            verbose_mode
+            skip_bundler
+          ).each do |option_to_parse|
+            send(option_to_parse, option)
+          end
+          banner(option)
+          help(option)
+        end
+      end
+
+      def parse!
+        @options_parser.parse!(@arguments)
+
+        self
+      end
+
+      def ruby_strategy(option)
+        option.on('--ruby strategy', 'Ruby Manager. Ex.: auto_discover, rvm, rbenv, ruby_default') do |strategy|
+          @strategy = strategy.to_sym
+        end
+      end
+
+      def ruby_versions(option)
+        option.on('--rubies=rubies', 'Specify Ruby version(s) to test against') do |versions|
+          @rubies = versions.split(',')
+        end
+      end
+
+      def options_to_added_in_the_command(option)
+        option.on('--options=options', 'Pass the options to be added. Ex. -Ilib-Itest-Iapp') do |options|
+          @specific_options = options.split('-').join(' -').strip
+        end
+      end
+
+      def test_framework_to_be_run(option)
+        option.on('--test library', 'Test Framework to be run. Ex.: auto_discover, rspec, test_unit.') do |library|
+          @test_framework = library.to_sym
+        end
+      end
+
+      def app_framework(option)
+        option.on('--framework library', 'Application Framework to be run and added the patterns to search changed files. Ex.: auto_discover, rails, rubygems, padrino.') do |library|
+          @framework = library.to_sym
+        end
+      end
+
+      def notifications_library(option)
+        option.on('--notifications library', 'Notification library to use. Ex.: auto_discover, osascript, terminal_notifier, notify_send, dunstify.') do |library|
+          @notifications = library.to_sym
+        end
+      end
+
+      def image_mode(option)
+        option.on('--mode theme', 'Image theme for notifications. Ex.: simpson, faces, fuuu, hands, mario_bros, rails, rubies, street_fighter, toy_story.') do |theme|
+          @mode = theme.to_sym
+        end
+      end
+
+      def infinity_and_beyond_option(option)
+        option.on('-n', '--no-infinity-and-beyond', 'Run tests and exit. Useful in a Continuous Integration environment.') do
+          @infinity_and_beyond = false
+        end
+      end
+
+      def just_watch_option(option)
+        option.on('-j', '--just-watch', 'Skip initial test run and only watch for file changes. Useful for large applications.') do
+          @just_watch = true
+        end
+      end
+
+      def focus_option(option)
+        option.on('-f', '--focus [FILE]', 'Focus on specific tests. Use "failures" for failed tests, or provide a file path.') do |file|
+          @focus = file == 'failures' ? :failures : file
+        end
+      end
+
+      def verbose_mode(option)
+        option.on('--no-verbose', "Don't print commands before executing them") do
+          @verbose = false
+        end
+      end
+
+      def skip_bundler(option)
+        option.on('--no-bundler', "Bypass Infinity Test's Bundler support") do
+          @bundler = false
+        end
+      end
+
+      def banner(option)
+        option.banner = [ "Usage: infinity_test [options]", "Run tests"].join("\n")
+      end
+
+      def help(option)
+        option.on_tail("--help", "You're looking at it.") do
+          print option.help
+          exit
+        end
+      end
+
+      def verbose?
+        @verbose
+      end
+
+      def bundler?
+        @bundler
+      end
+    end
+  end
+end

data/lib/infinity_test/core/runner.rb

@@ -0,0 +1,18 @@
+module InfinityTest
+  module Core
+    class Runner
+      attr_accessor :options
+
+      def initialize(*arguments)
+        @options = Options.new(arguments).parse!
+      end
+
+      def start
+        Core::LoadConfiguration.new.load!
+        Core::Base.merge!(options)
+        Core::AutoDiscover.new(Core::Base).discover_libraries
+        Core::Base.start_continuous_test_server
+      end
+    end
+  end
+end

data/lib/infinity_test/core/version.rb

@@ -0,0 +1,5 @@
+module InfinityTest
+  module Core
+    VERSION = '2.0.0.rc1'
+  end
+end

data/lib/infinity_test/framework/base.rb

@@ -0,0 +1,57 @@
+module InfinityTest
+  module Framework
+    class Base
+      attr_reader :continuous_test_server, :hike
+      delegate :observer, :test_framework, :extension, to: :continuous_test_server
+      delegate :watch, :watch_dir, to: :observer
+
+      def initialize(continuous_test_server)
+        @continuous_test_server = continuous_test_server
+        @hike = Hike::Trail.new(Dir.pwd)
+      end
+
+      def heuristics!
+        hike.append_extension(extension)
+        hike.append_path(test_framework.test_dir)
+        heuristics
+      end
+
+      # This method is called for the InfinityTest before starting the observer
+      #
+      def heuristics
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      # Put all the requires to autodiscover use your framework instead of others.
+      #
+      def self.run?
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      # Run all the strategy again.
+      #
+      def run_all
+        continuous_test_server.run_strategy
+      end
+
+      # Run the same changed file.
+      # E.g: the user saves the test file, runs the test file.
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_file(changed_file)
+        continuous_test_server.rerun_strategy(changed_file.name)
+      end
+
+      # Run test based on the changed file.
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_test(changed_file)
+        file_name = "#{changed_file.path}_#{test_framework.test_dir}.#{extension}"
+        file      = hike.find(file_name)
+        continuous_test_server.rerun_strategy(file) if file.present?
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/padrino.rb

@@ -0,0 +1,33 @@
+module InfinityTest
+  module Framework
+    class Padrino < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch app folder (models, controllers, helpers, mailers) and run corresponding tests/specs
+      #  * Watch lib dir and run corresponding tests
+      #  * Watch test/spec dir and run the changed file
+      #  * Watch test/spec helper and run all
+      #
+      def heuristics
+        watch_dir('app/models')      { |file| run_test(file) }
+        watch_dir('app/controllers') { |file| run_test(file) }
+        watch_dir('app/helpers')     { |file| run_test(file) }
+        watch_dir('app/mailers')     { |file| run_test(file) }
+        watch_dir(:lib)              { |file| run_test(file) }
+        watch_dir(test_dir)          { |file| run_file(file) }
+        watch(test_helper_file)      { run_all }
+      end
+
+      # ==== Returns
+      #  TrueClass: Find the config/apps.rb in the user current dir
+      #  FalseClass: Don't Find the config/apps.rb in the user current dir
+      #
+      def self.run?
+        File.exist?(File.expand_path('./config/apps.rb'))
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/rails.rb

@@ -0,0 +1,35 @@
+module InfinityTest
+  module Framework
+    class Rails < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch app/models and run corresponding tests/specs
+      #  * Watch app/controllers and run corresponding tests/specs
+      #  * Watch app/helpers and run corresponding tests/specs
+      #  * Watch app/mailers and run corresponding tests/specs
+      #  * Watch app/jobs and run corresponding tests/specs
+      #  * Watch lib dir and run corresponding tests
+      #  * Watch test/spec dir and run the changed file
+      #  * Watch test/spec helper and run all
+      #  * Watch config/routes.rb and run routing specs
+      #
+      def heuristics
+        watch_dir('app/models')      { |file| run_test(file) }
+        watch_dir('app/controllers') { |file| run_test(file) }
+        watch_dir('app/helpers')     { |file| run_test(file) }
+        watch_dir('app/mailers')     { |file| run_test(file) }
+        watch_dir('app/jobs')        { |file| run_test(file) }
+        watch_dir(:lib)              { |file| run_test(file) }
+        watch_dir(test_dir)          { |file| run_file(file) }
+        watch(test_helper_file)      { run_all }
+      end
+
+      def self.run?
+        File.exist?(File.expand_path('./config/environment.rb'))
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/rubygems.rb

@@ -0,0 +1,29 @@
+module InfinityTest
+  module Framework
+    class Rubygems < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Add Gemfile and Run bundle install and run all specs.
+      #  * Observe lib dir and run test.
+      #  * Observe the test dir and run the same changed file.
+      #  * Observe the test helper file and run.
+      #
+      def heuristics
+        watch_dir(:lib)         { |file| run_test(file) }
+        watch_dir(test_dir)     { |file| run_file(file) }
+        watch(test_helper_file) { run_all }
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a gemspec in the user current dir
+      #  FalseClass: Don't Find a gemspec in the user current dir
+      #
+      def self.run?
+        Dir["*.gemspec"].present?
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/shared_example.rb

@@ -0,0 +1,47 @@
+module InfinityTest
+  module Framework
+    module SharedExample
+      # Shared Examples to use in the RSpec specs when you want create your own observer.
+      #
+      # ==== Examples
+      #
+      #   RSpec.configure do |config|
+      #     config.include InfinityTest::Observer::SharedExample
+      #   end
+      #
+      #   describe BarObserver do
+      #     it_should_behave_like 'an infinity test observer'
+      #   end
+      #
+      shared_examples_for 'an infinity test framework' do
+        it 'responds to #heuristics' do
+          expect(subject).to respond_to(:heuristics)
+        end
+
+        it 'responds to #heuristics!' do
+          expect(subject).to respond_to(:heuristics!)
+        end
+
+        it 'responds to .run?' do
+          expect(subject.class).to respond_to(:run?)
+        end
+
+        it 'responds to #base' do
+          expect(subject).to respond_to(:base)
+        end
+
+        it 'responds to #test_framework' do
+          expect(subject).to respond_to(:test_framework)
+        end
+
+        it 'responds to #strategy' do
+          expect(subject).to respond_to(:strategy)
+        end
+
+        it 'responds to #observer' do
+          expect(subject).to respond_to(:observer)
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/observer/base.rb

@@ -0,0 +1,40 @@
+module InfinityTest
+  module Observer
+    class Base
+      attr_accessor :continuous_test_server
+
+      def initialize(continuous_test_server)
+        @continuous_test_server = continuous_test_server
+      end
+
+      def watch(pattern_or_file, &block)
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def watch_dir(dir_name, extension, &block)
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def start!
+        signal
+        start
+      end
+
+      def start
+        raise NotImplementedError, "not implemented in #{self}"
+      end
+
+      def signal
+        Signal.trap('INT') do
+          if @interrupt_at && (Time.now - @interrupt_at) < 2
+            puts " To Infinity and Beyond!"
+            exit
+          else
+            puts " Are you sure? :S ... Interrupt a second time to quit!"
+            @interrupt_at = Time.now
+          end
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/observer/filewatcher.rb

@@ -0,0 +1,72 @@
+require 'filewatcher'
+
+module InfinityTest
+  module Observer
+    class Filewatcher < Base
+      attr_reader :observer, :watch_paths, :patterns
+
+      def initialize(continuous_test_server)
+        super
+        @watch_paths = []
+        @patterns = {}
+      end
+
+      # Watch a file or pattern for changes.
+      #
+      # ==== Examples
+      #
+      #   watch('lib/(.*)\.rb') { |file| puts [file.name, file.path, file.match_data] }
+      #   watch('test/test_helper.rb') { run_all() }
+      #
+      def watch(pattern_or_file, &block)
+        pattern = Regexp.new(pattern_or_file.to_s)
+        @patterns[pattern] = block
+      end
+
+      # Watch a directory for changes.
+      #
+      # ==== Examples
+      #
+      #   watch_dir(:lib)  { |file| run_test(file) }
+      #   watch_dir(:test) { |file| run_file(file) }
+      #
+      #   watch_dir(:test, :py) { |file| puts [file.name, file.path, file.match_data] }
+      #   watch_dir(:test, :js) { |file| puts [file.name, file.path, file.match_data] }
+      #
+      def watch_dir(dir_name, extension = :rb, &block)
+        watch("^#{dir_name}/*/(.*).#{extension}", &block)
+        path = "#{dir_name}/**/*.#{extension}"
+        @watch_paths << path unless @watch_paths.include?(path)
+      end
+
+      # Start the continuous test server.
+      #
+      def start
+        paths = @watch_paths.empty? ? ['**/*.rb'] : @watch_paths
+
+        @observer = ::Filewatcher.new(paths)
+
+        @observer.watch do |changes|
+          changes.each do |file_path, _event|
+            relative_path = file_path.sub("#{Dir.pwd}/", '')
+            handle_file_change(relative_path)
+          end
+        end
+      rescue Interrupt
+        @observer.stop if @observer
+      end
+
+      private
+
+      def handle_file_change(file_path)
+        @patterns.each do |pattern, block|
+          if match_data = pattern.match(file_path)
+            changed_file = InfinityTest::Core::ChangedFile.new(match_data)
+            block.call(changed_file)
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/observer/listen.rb

@@ -0,0 +1,74 @@
+require 'listen'
+
+module InfinityTest
+  module Observer
+    class Listen < Base
+      attr_reader :observer, :directories, :patterns
+
+      def initialize(continuous_test_server)
+        super
+        @directories = []
+        @patterns = {}
+      end
+
+      # Watch a file or pattern for changes.
+      #
+      # ==== Examples
+      #
+      #   watch('lib/(.*)\.rb') { |file| puts [file.name, file.path, file.match_data] }
+      #   watch('test/test_helper.rb') { run_all() }
+      #
+      def watch(pattern_or_file, &block)
+        pattern = Regexp.new(pattern_or_file.to_s)
+        @patterns[pattern] = block
+      end
+
+      # Watch a directory for changes.
+      #
+      # ==== Examples
+      #
+      #   watch_dir(:lib)  { |file| run_test(file) }
+      #   watch_dir(:test) { |file| run_file(file) }
+      #
+      #   watch_dir(:test, :py) { |file| puts [file.name, file.path, file.match_data] }
+      #   watch_dir(:test, :js) { |file| puts [file.name, file.path, file.match_data] }
+      #
+      def watch_dir(dir_name, extension = :rb, &block)
+        watch("^#{dir_name}/*/(.*).#{extension}", &block)
+        @directories << dir_name.to_s unless @directories.include?(dir_name.to_s)
+      end
+
+      # Start the continuous test server.
+      #
+      def start
+        dirs = @directories.empty? ? ['.'] : @directories
+        dirs = dirs.select { |d| File.directory?(d) }
+        dirs = ['.'] if dirs.empty?
+
+        @observer = ::Listen.to(*dirs) do |modified, added, _removed|
+          (modified + added).each do |file|
+            relative_path = file.sub("#{Dir.pwd}/", '')
+            handle_file_change(relative_path)
+          end
+        end
+
+        @observer.start
+        sleep
+      rescue Interrupt
+        @observer.stop if @observer
+      end
+
+      private
+
+      def handle_file_change(file_path)
+        @patterns.each do |pattern, block|
+          if match_data = pattern.match(file_path)
+            changed_file = InfinityTest::Core::ChangedFile.new(match_data)
+            block.call(changed_file)
+            break
+          end
+        end
+      end
+    end
+  end
+end

data/lib/infinity_test/observer/shared_example.rb

@@ -0,0 +1,35 @@
+module InfinityTest
+  module Observer
+    module SharedExample
+      # Shared Examples to use in the RSpec specs when you want create your own observer.
+      #
+      # ==== Examples
+      #
+      #   RSpec.configure do |config|
+      #     config.include InfinityTest::Observer::SharedExample
+      #   end
+      #
+      #   describe BarObserver do
+      #     it_should_behave_like 'an infinity test observer'
+      #   end
+      #
+      shared_examples_for 'an infinity test observer' do
+        it 'responds to #observer' do
+          expect(subject).to respond_to(:observer)
+        end
+
+        it 'responds to #watch_dir' do
+          expect(subject).to respond_to(:watch_dir)
+        end
+
+        it 'responds to #watch' do
+          expect(subject).to respond_to(:watch)
+        end
+
+        it 'responds to #start' do
+          expect(subject).to respond_to(:start)
+        end
+      end
+    end
+  end
+end