infinity_test 1.0.3 → 2.0.0.rc2

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.rc2'
+  end
+end

data/lib/infinity_test/framework/base.rb

@@ -0,0 +1,93 @@
+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
+
+      # Auto-discover and watch all directories under app/ that contain Ruby files.
+      # Maps app/components to spec/components, app/wizards to spec/wizards, etc.
+      # Skips directories without .rb files (e.g., app/views, app/assets).
+      #
+      def watch_app_dirs
+        return unless File.directory?('app')
+
+        Dir.glob('app/*').each do |app_dir|
+          next unless File.directory?(app_dir)
+          next unless Dir.glob("#{app_dir}/**/*.rb").any?
+
+          watch_dir(app_dir) { |file| run_test_in_subdir(file, app_dir) }
+        end
+      end
+
+      # Run test preserving the subdirectory structure.
+      # E.g: app/components/wizard.rb -> spec/components/wizard_spec.rb
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      # @param app_dir [String] The app directory (e.g., 'app/components')
+      #
+      def run_test_in_subdir(changed_file, app_dir)
+        subdir = File.basename(app_dir)
+        test_file = File.join(test_framework.test_dir, subdir, "#{changed_file.path}_#{test_framework.test_dir}.#{extension}")
+
+        if File.exist?(test_file)
+          continuous_test_server.rerun_strategy(test_file)
+        else
+          # Fallback: try finding with hike in test_dir/subdir
+          hike.prepend_path(File.join(test_framework.test_dir, subdir))
+          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
+end

data/lib/infinity_test/framework/django.rb

@@ -0,0 +1,109 @@
+module InfinityTest
+  module Framework
+    class Django < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Override to use .py extension for Python test files.
+      #
+      def heuristics!
+        hike.append_extension('.py')
+        hike.append_path(test_framework.test_dir)
+        heuristics
+      end
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch all Django app directories
+      #  * Watch test dir (.py files) and run the changed file
+      #  * Watch conftest.py and run all tests
+      #
+      def heuristics
+        watch_django_apps
+        watch_dir(test_dir, :py) { |file| run_file(file) } if File.directory?(test_dir.to_s)
+        watch(test_helper_file) { run_all } if File.exist?(test_helper_file.to_s)
+      end
+
+      # Auto-discover and watch Django app directories.
+      # Django apps have models.py, views.py, or apps.py
+      #
+      def watch_django_apps
+        django_apps = detect_django_apps
+
+        django_apps.each do |app_dir|
+          next unless File.directory?(app_dir)
+
+          watch_dir(app_dir, :py) { |file| run_app_test(file, app_dir) }
+        end
+      end
+
+      # Run test for a Django app file.
+      # Maps myapp/models.py -> myapp/tests/test_models.py or myapp/tests.py
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      # @param app_dir [String] The Django app directory
+      #
+      def run_app_test(changed_file, app_dir)
+        basename = File.basename(changed_file.path, '.py')
+        app_name = File.basename(app_dir)
+
+        # Try app/tests/test_*.py pattern
+        test_file = File.join(app_dir, 'tests', "test_#{basename}.py")
+        if File.exist?(test_file)
+          continuous_test_server.rerun_strategy(test_file)
+          return
+        end
+
+        # Try app/tests.py (single test file)
+        test_file = File.join(app_dir, 'tests.py')
+        if File.exist?(test_file)
+          continuous_test_server.rerun_strategy(test_file)
+          return
+        end
+
+        # Fallback: run all app tests
+        test_dir = File.join(app_dir, 'tests')
+        if File.directory?(test_dir)
+          continuous_test_server.rerun_strategy(test_dir)
+        end
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a Django project (manage.py exists)
+      #  FalseClass: Not a Django project
+      #
+      def self.run?
+        File.exist?('manage.py') && django_project?
+      end
+
+      def self.django_project?
+        return false unless File.exist?('manage.py')
+        content = File.read('manage.py')
+        content.include?('django') || content.include?('DJANGO')
+      rescue
+        false
+      end
+
+      private
+
+      def detect_django_apps
+        apps = []
+
+        # Find directories with Django app markers
+        Dir.glob('*').each do |dir|
+          next unless File.directory?(dir)
+          next if %w[tests test static templates media venv .venv node_modules].include?(dir)
+
+          # Check for Django app markers
+          has_models = File.exist?(File.join(dir, 'models.py'))
+          has_views = File.exist?(File.join(dir, 'views.py'))
+          has_apps = File.exist?(File.join(dir, 'apps.py'))
+
+          apps << dir if has_models || has_views || has_apps
+        end
+
+        apps
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/elixir_mix.rb

@@ -0,0 +1,47 @@
+module InfinityTest
+  module Framework
+    class ElixirMix < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Override to use .exs extension for Elixir test files.
+      #
+      def heuristics!
+        hike.append_extension('.exs')
+        hike.append_path(test_framework.test_dir)
+        heuristics
+      end
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Observe lib dir (.ex files) and run corresponding test.
+      #  * Observe the test dir (.exs files) and run the same changed file.
+      #  * Observe the test helper file and run all tests.
+      #
+      def heuristics
+        watch_dir(:lib, :ex)    { |file| run_test(file) }
+        watch_dir(test_dir, :exs) { |file| run_file(file) }
+        watch(test_helper_file) { run_all }
+      end
+
+      # Run test based on the changed file.
+      # Maps lib/my_app/user.ex -> test/my_app/user_test.exs
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_test(changed_file)
+        file_name = "#{changed_file.path}_test.exs"
+        file = hike.find(file_name)
+        continuous_test_server.rerun_strategy(file) if file.present?
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a mix.exs in the user current dir
+      #  FalseClass: Don't Find a mix.exs in the user current dir
+      #
+      def self.run?
+        File.exist?('mix.exs')
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/fast_api.rb

@@ -0,0 +1,104 @@
+module InfinityTest
+  module Framework
+    class FastApi < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Override to use .py extension for Python test files.
+      #
+      def heuristics!
+        hike.append_extension('.py')
+        hike.append_path(test_framework.test_dir)
+        heuristics
+      end
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch app dir (.py files) for FastAPI applications
+      #  * Watch src dir (.py files) if exists
+      #  * Watch routers/endpoints directories
+      #  * Watch test dir (.py files) and run the changed file
+      #  * Watch conftest.py and run all tests
+      #
+      def heuristics
+        watch_fastapi_dirs
+        watch_dir(test_dir, :py) { |file| run_file(file) }
+        watch(test_helper_file) { run_all } if File.exist?(test_helper_file.to_s)
+      end
+
+      # Auto-discover and watch FastAPI source directories.
+      # Common patterns: app/, src/, routers/, api/
+      #
+      def watch_fastapi_dirs
+        fastapi_dirs = detect_fastapi_source_dirs
+
+        fastapi_dirs.each do |dir|
+          next unless File.directory?(dir)
+          next unless Dir.glob("#{dir}/**/*.py").any?
+
+          watch_dir(dir, :py) { |file| run_test(file) }
+        end
+      end
+
+      # Run test based on the changed file.
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_test(changed_file)
+        test_file = find_test_file(changed_file.path)
+        continuous_test_server.rerun_strategy(test_file) if test_file.present?
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a FastAPI project (app/main.py or main.py with FastAPI)
+      #  FalseClass: Not a FastAPI project
+      #
+      def self.run?
+        return true if File.exist?('app/main.py') && fastapi_in_file?('app/main.py')
+        return true if File.exist?('main.py') && fastapi_in_file?('main.py')
+        return true if File.exist?('src/main.py') && fastapi_in_file?('src/main.py')
+        false
+      end
+
+      def self.fastapi_in_file?(file)
+        return false unless File.exist?(file)
+        content = File.read(file)
+        content.include?('fastapi') || content.include?('FastAPI')
+      rescue
+        false
+      end
+
+      private
+
+      def detect_fastapi_source_dirs
+        dirs = []
+        dirs << 'app' if File.directory?('app')
+        dirs << 'src' if File.directory?('src')
+        dirs << 'routers' if File.directory?('routers')
+        dirs << 'api' if File.directory?('api')
+        dirs << 'endpoints' if File.directory?('endpoints')
+
+        # Also watch root .py files for simple FastAPI apps
+        dirs << '.' if Dir.glob('*.py').any? { |f| !f.start_with?('test_') }
+
+        dirs.uniq
+      end
+
+      def find_test_file(source_path)
+        basename = File.basename(source_path, '.py')
+
+        patterns = [
+          "test_#{basename}.py",
+          "#{basename}_test.py"
+        ]
+
+        patterns.each do |pattern|
+          file = hike.find(pattern)
+          return file if file.present?
+        end
+
+        nil
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/padrino.rb

@@ -0,0 +1,30 @@
+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 all app/* directories 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_app_dirs
+        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