infinity_test 2.0.0.rc1 → 2.0.0.rc2

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

@@ -6,19 +6,16 @@ module InfinityTest
       # Add Heuristics to the observer run on pattern changes!
       #
       # ==== Heuristics
-      #  * Watch app folder (models, controllers, helpers, mailers) and run corresponding tests/specs
+      #  * 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_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 }
+        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

data/lib/infinity_test/framework/phoenix.rb

@@ -0,0 +1,72 @@
+module InfinityTest
+  module Framework
+    class Phoenix < 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
+      #  * Watch all lib/*_web directories (controllers, views, live, channels)
+      #  * Watch lib dir (.ex files) and run corresponding test
+      #  * Watch test dir (.exs files) and run the changed file
+      #  * Watch test helper and run all tests
+      #
+      def heuristics
+        watch_lib_dirs
+        watch_dir(test_dir, :exs) { |file| run_file(file) }
+        watch(test_helper_file) { run_all }
+      end
+
+      # Auto-discover and watch all directories under lib/ that contain .ex files.
+      # Maps lib/my_app/accounts to test/my_app/accounts, etc.
+      #
+      def watch_lib_dirs
+        return unless File.directory?('lib')
+
+        Dir.glob('lib/*').each do |lib_dir|
+          next unless File.directory?(lib_dir)
+          next unless Dir.glob("#{lib_dir}/**/*.ex").any?
+
+          watch_dir(lib_dir, :ex) { |file| run_test_in_lib(file, lib_dir) }
+        end
+      end
+
+      # Run test preserving the directory structure.
+      # E.g: lib/my_app_web/controllers/user_controller.ex -> test/my_app_web/controllers/user_controller_test.exs
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      # @param lib_dir [String] The lib directory (e.g., 'lib/my_app_web')
+      #
+      def run_test_in_lib(changed_file, lib_dir)
+        subdir = File.basename(lib_dir)
+        test_file = File.join(test_framework.test_dir, subdir, "#{changed_file.path}_test.exs")
+
+        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.exs"
+          file = hike.find(file_name)
+          continuous_test_server.rerun_strategy(file) if file.present?
+        end
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a Phoenix project (has lib/*_web directory)
+      #  FalseClass: Not a Phoenix project
+      #
+      def self.run?
+        File.exist?('mix.exs') && Dir.glob('lib/*_web').any?
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/python_package.rb

@@ -0,0 +1,97 @@
+module InfinityTest
+  module Framework
+    class PythonPackage < 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 src dir (.py files) and run corresponding test
+      #  * Watch package dirs (.py files) and run corresponding test
+      #  * Watch test dir (.py files) and run the changed file
+      #  * Watch conftest.py and run all tests
+      #
+      def heuristics
+        watch_python_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 Python source directories.
+      # Common patterns: src/, package_name/, lib/
+      #
+      def watch_python_dirs
+        python_dirs = detect_python_source_dirs
+
+        python_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.
+      # Maps src/mypackage/utils.py -> tests/test_utils.py or tests/mypackage/test_utils.py
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_test(changed_file)
+        # Try test_filename.py pattern first
+        test_file = find_test_file(changed_file.path)
+        continuous_test_server.rerun_strategy(test_file) if test_file.present?
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a Python package (pyproject.toml, setup.py, or setup.cfg)
+      #  FalseClass: Not a Python package
+      #
+      def self.run?
+        File.exist?('pyproject.toml') ||
+          File.exist?('setup.py') ||
+          File.exist?('setup.cfg')
+      end
+
+      private
+
+      def detect_python_source_dirs
+        dirs = []
+        dirs << 'src' if File.directory?('src')
+        dirs << 'lib' if File.directory?('lib') && Dir.glob('lib/**/*.py').any?
+
+        # Detect package directories (directories with __init__.py)
+        Dir.glob('*/__init__.py').each do |init_file|
+          dir = File.dirname(init_file)
+          dirs << dir unless %w[tests test].include?(dir)
+        end
+
+        dirs.uniq
+      end
+
+      def find_test_file(source_path)
+        basename = File.basename(source_path, '.py')
+
+        # Try various test file patterns
+        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/rails.rb

@@ -6,25 +6,16 @@ module InfinityTest
       # 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 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
-      #  * 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 }
+        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
 
       def self.run?

data/lib/infinity_test/framework/rocket.rb

@@ -0,0 +1,70 @@
+module InfinityTest
+  module Framework
+    class Rocket < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Override to use .rs extension for Rust files.
+      #
+      def heuristics!
+        hike.append_extension('.rs')
+        hike.append_path(test_framework.test_dir) if File.directory?(test_framework.test_dir.to_s)
+        heuristics
+      end
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch src dir (.rs files) and run tests matching the module name
+      #  * Watch tests dir (.rs files) and run the changed integration test
+      #  * Watch Cargo.toml and run all tests
+      #  * Watch Rocket.toml if exists and run all tests
+      #
+      def heuristics
+        watch_dir(:src, :rs) { |file| run_module_tests(file) }
+        watch_dir(test_dir, :rs) { |file| run_integration_test(file) } if File.directory?(test_dir.to_s)
+        watch(test_helper_file) { run_all }
+        watch('Rocket.toml') { run_all } if File.exist?('Rocket.toml')
+      end
+
+      # Run tests matching the module name.
+      # E.g: src/routes.rs -> cargo test routes
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_module_tests(changed_file)
+        module_name = File.basename(changed_file.name, '.rs')
+        # lib.rs and main.rs changes should run all tests
+        if %w[lib main].include?(module_name)
+          run_all
+        else
+          continuous_test_server.rerun_strategy(module_name)
+        end
+      end
+
+      # Run a specific integration test file.
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_integration_test(changed_file)
+        test_name = File.basename(changed_file.name, '.rs')
+        continuous_test_server.rerun_strategy("--test #{test_name}")
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a Rocket project (Cargo.toml with rocket dependency)
+      #  FalseClass: Not a Rocket project
+      #
+      def self.run?
+        File.exist?('Cargo.toml') && rocket_project?
+      end
+
+      def self.rocket_project?
+        return false unless File.exist?('Cargo.toml')
+        content = File.read('Cargo.toml')
+        content.include?('rocket')
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/infinity_test/framework/rust_cargo.rb

@@ -0,0 +1,69 @@
+module InfinityTest
+  module Framework
+    class RustCargo < Base
+      delegate :test_dir, :test_helper_file, to: :test_framework
+
+      # Override to use .rs extension for Rust files.
+      #
+      def heuristics!
+        hike.append_extension('.rs')
+        hike.append_path(test_framework.test_dir) if File.directory?(test_framework.test_dir.to_s)
+        heuristics
+      end
+
+      # Add Heuristics to the observer run on pattern changes!
+      #
+      # ==== Heuristics
+      #  * Watch src dir (.rs files) and run tests matching the module name
+      #  * Watch tests dir (.rs files) and run the changed integration test
+      #  * Watch Cargo.toml and run all tests
+      #
+      def heuristics
+        watch_dir(:src, :rs) { |file| run_module_tests(file) }
+        watch_dir(test_dir, :rs) { |file| run_integration_test(file) } if File.directory?(test_dir.to_s)
+        watch(test_helper_file) { run_all }
+      end
+
+      # Run tests matching the module name.
+      # E.g: src/user.rs -> cargo test user
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_module_tests(changed_file)
+        module_name = File.basename(changed_file.name, '.rs')
+        # lib.rs and main.rs changes should run all tests
+        if %w[lib main].include?(module_name)
+          run_all
+        else
+          continuous_test_server.rerun_strategy(module_name)
+        end
+      end
+
+      # Run a specific integration test file.
+      # For tests in tests/, run cargo test --test <name>
+      #
+      # @param changed_file [<InfinityTest::Core::ChangedFile>]
+      #
+      def run_integration_test(changed_file)
+        test_name = File.basename(changed_file.name, '.rs')
+        continuous_test_server.rerun_strategy("--test #{test_name}")
+      end
+
+      # ==== Returns
+      #  TrueClass: Find a Rust project (Cargo.toml exists)
+      #  FalseClass: Not a Rust project
+      #
+      def self.run?
+        File.exist?('Cargo.toml') && !rocket_project?
+      end
+
+      def self.rocket_project?
+        return false unless File.exist?('Cargo.toml')
+        content = File.read('Cargo.toml')
+        content.include?('rocket')
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/infinity_test/strategy/base.rb

@@ -13,9 +13,25 @@ module InfinityTest
       end
 
       # Run the strategy and parse the results storing in the strategy.
+      # Prints the command before executing if verbose mode is enabled.
       #
       def run
-        Core::CommandRunner.new(run!)
+        command = run!
+        puts "\n\e[96m[InfinityTest]\e[0m - Command: '\e[32m#{command}\e[0m'\n\n" if Core::Base.verbose?
+        Core::CommandRunner.new(command)
+      end
+
+      # Check if bundler should be used.
+      # Returns true if bundler is enabled and Gemfile exists.
+      #
+      def use_bundler?
+        Core::Base.using_bundler? && File.exist?('Gemfile')
+      end
+
+      # Wrap command with bundle exec if bundler should be used.
+      #
+      def with_bundler(command)
+        use_bundler? ? "bundle exec #{command}" : command
       end
 
       # Implement #run! method returning a string command to be run.

data/lib/infinity_test/strategy/elixir_default.rb

@@ -0,0 +1,20 @@
+module InfinityTest
+  module Strategy
+    class ElixirDefault < Base
+      attr_reader :continuous_test_server
+      delegate :binary, :test_files, to: :continuous_test_server
+
+      def run!
+        command = "#{binary} test #{test_files}"
+        command = "#{command} #{Core::Base.specific_options}" if Core::Base.specific_options.present?
+        command
+      end
+
+      # Run when the project has mix.exs (Elixir project)
+      #
+      def self.run?
+        File.exist?('mix.exs')
+      end
+    end
+  end
+end