infinity_test 2.0.0.rc1 → 2.0.0.rc2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: de5c732203c3b409f78bed3dfeb549cc51e473bba5777b5cfa7c25ea4ced3727
-  data.tar.gz: c0e116e50c6d435b892507c4643e615467be709453840ed23fe946a1edd3d071
+  metadata.gz: a6911d2416f7e79b5629dda190203656dad3c90b8b10dae6e8abaf0103412082
+  data.tar.gz: 5434be704db02566f39a2f6272eb238f648956d6396eb95b3ad0da5f44ef6d10
 SHA512:
-  metadata.gz: b1e7d0fc5bce31d3bdc2ed40d01fea49561702b78900460a735b41b8425b2f16e725c21e5add80dfb13b952e6ee70058432d65b1254ce78b7081ac6ce820ab64
-  data.tar.gz: 0a2d0157905c8fa52bb8bb6f07424317346ff3c1dc1f274821a9d6cb9099105e4e228a987bf7f2ab66e0e4d8e3ee00d63312c723a2838da91a54e98ae7dde0af
+  metadata.gz: 3401363f1c87b54b3242a518f7ff70f9c9c401753e22be535a24ea59984f902cda041363777fe32b0b416b168d30b18be4ed76dbdd981d29d67aeab5f7268242
+  data.tar.gz: 46cb6773e7ddce619f210c120b2ab4b88085266af6da383b593d90a4b8bc3430d4baa3386012d35ef7280efeafd8eaf8c40e231ca518d0f66676021b2a2f1a37

data/HISTORY.md

@@ -0,0 +1,84 @@
+# History
+
+## 2.0.0
+
+### New Features
+
+- **Elixir Support**: Added ExUnit test framework, ElixirMix and Phoenix frameworks, and ElixirDefault strategy
+  - Auto-discovers Elixir projects by detecting `mix.exs`
+  - Phoenix framework: detects `lib/*_web` directory, watches all lib subdirectories
+  - ElixirMix framework: for standard Mix projects
+  - Watches `lib/**/*.ex` and `test/**/*.exs` files
+  - Parses ExUnit output (tests, failures, skipped)
+
+- **Python Support**: Added Pytest test framework, PythonPackage framework, and PythonDefault strategy
+  - Auto-discovers Python projects by detecting `pyproject.toml`, `setup.py`, or `setup.cfg`
+  - Watches `src/`, `lib/`, and package directories with `__init__.py`
+  - Watches `tests/` or `test/` directories for test files
+  - Parses Pytest output (passed, failed, skipped)
+
+- **Django Framework**: Full support for Django projects
+  - Auto-discovers Django projects by detecting `manage.py` with Django imports
+  - Watches Django app directories (models.py, views.py, apps.py)
+  - Maps app files to their corresponding tests
+
+- **FastAPI Framework**: Support for FastAPI/ML API projects
+  - Auto-discovers FastAPI projects by detecting FastAPI imports in main.py
+  - Watches `app/`, `src/`, `routers/`, `api/`, `endpoints/` directories
+  - Perfect for ML model serving APIs
+
+- **Rust Support**: Added CargoTest test framework, RustCargo and Rocket frameworks, and RustDefault strategy
+  - Auto-discovers Rust projects by detecting `Cargo.toml`
+  - Rocket framework: detects `rocket` dependency in Cargo.toml
+  - Watches `src/*.rs` files and runs tests matching module names
+  - Watches `tests/*.rs` for integration tests
+  - Parses cargo test output (passed, failed, ignored)
+
+- **Modern Observers**: Replaced watchr with listen and filewatcher observers
+  - `listen` (default): Event-driven, uses native OS notifications
+  - `filewatcher`: Polling-based, works in VMs/NFS environments
+
+- **RVM and RbEnv Strategies**: Multi-version Ruby testing support
+  - Run tests against multiple Ruby versions simultaneously
+  - Gemset support for RVM
+
+- **Callbacks System**: Before/after hooks for test runs
+  - `before(:all)`, `after(:all)` for all test runs
+  - `before(:each_ruby)`, `after(:each_ruby)` for each Ruby version
+
+- **Focus Mode**: Run specific tests with `--focus` option
+  - `--focus=:failures` to run only previously failed tests
+  - `--focus=path/to/file` to run specific test file
+
+- **Just Watch Mode**: `--just-watch` option to skip initial test run
+
+- **Auto-discover App Directories**: Automatically detect and watch Rails/Padrino app subdirectories (models, controllers, components, etc.)
+
+- **Start Banner**: Display configuration summary on startup
+
+- **Bundler Support**: Automatic `bundle exec` wrapping when Gemfile is present
+
+- **Colored Output**: Preserve terminal colors with PTY and verbose command display
+
+- **CLI Options**: Added `--notifications` and `--mode` options for desktop notifications
+
+### Improvements
+
+- **Modern Notifications**: Updated to use modern notifiers gem with support for:
+  - macOS: terminal-notifier, osascript
+  - Linux: notify-send, dunstify
+
+- **Priority Ordering**: Auto-discover now respects priority order for strategies, frameworks, and test frameworks
+
+- **Rails and Padrino Heuristics**: Improved file watching patterns for Rails and Padrino applications
+
+- **GitHub Actions**: Replaced Travis CI with GitHub Actions for CI/CD
+
+- **Configuration File**: Renamed config file to `INFINITY_TEST`
+
+### Compatibility
+
+- Updated for Ruby 3.x compatibility
+- Updated for ActiveSupport 7.0+ compatibility
+- Updated for modern RSpec syntax (replaced deprecated `stub` with `allow().to receive()`)
+- Improved test descriptions by removing 'should' prefix

data/README.md

@@ -4,7 +4,7 @@
 
 Infinity Test is a continuous testing library and a flexible alternative to Autotest and Guard. It watches your files for changes and automatically runs your tests, providing instant feedback with desktop notifications.
 
-Version 2.0.0 brings a complete rewrite with modern dependencies, multi-Ruby support via RVM/RbEnv, and a powerful callbacks system.
+Version 2.0.0 brings a complete rewrite with modern dependencies, multi-Ruby support via RVM/RbEnv, a powerful callbacks system, and experimental support for Elixir (Phoenix, ExUnit), Python (Django, FastAPI, Pytest), and Rust (Rocket, Cargo).
 
 ## Table of Contents
 
@@ -15,6 +15,9 @@ Version 2.0.0 brings a complete rewrite with modern dependencies, multi-Ruby sup
 - [Ruby Version Managers](#ruby-version-managers)
 - [Test Frameworks](#test-frameworks)
 - [Application Frameworks](#application-frameworks)
+- [Experimental: Elixir Support](#experimental-elixir-support)
+- [Experimental: Python Support](#experimental-python-support)
+- [Experimental: Rust Support](#experimental-rust-support)
 - [Notifications](#notifications)
 - [Image Themes](#image-themes)
 - [Callbacks](#callbacks)
@@ -25,14 +28,16 @@ Version 2.0.0 brings a complete rewrite with modern dependencies, multi-Ruby sup
 
 ## Installation
 
+Since this is a release candidate (rc1), you need to explicitly request the pre-release version:
+
 ```bash
-gem install infinity_test
+gem install infinity_test --pre
 ```
 
 Or add to your Gemfile:
 
 ```ruby
-gem 'infinity_test', group: :development
+gem 'infinity_test', '~> 2.0.0.rc2', group: :development
 ```
 
 Then run:
@@ -59,8 +64,8 @@ infinity_test
 
 That's it! Infinity Test will:
 
-1. Auto-detect your test framework (RSpec or Test::Unit)
-2. Auto-detect your application framework (Rails, Padrino, or Rubygems)
+1. Auto-detect your test framework (RSpec, Test::Unit, ExUnit, or Pytest)
+2. Auto-detect your application framework (Rails, Padrino, Rubygems, Phoenix, Django, FastAPI, etc.)
 3. Run all tests immediately
 4. Watch for file changes and re-run relevant tests
 5. Show desktop notifications with test results
@@ -77,8 +82,8 @@ Edit your files and watch the tests run automatically!
 |--------|-------|-------------|
 | `--ruby strategy` | | Ruby manager strategy: `auto_discover`, `rvm`, `rbenv`, `ruby_default` |
 | `--rubies=versions` | | Ruby versions to test against (comma-separated) |
-| `--test library` | | Test framework: `auto_discover`, `rspec`, `test_unit` |
-| `--framework library` | | Application framework: `auto_discover`, `rails`, `rubygems`, `padrino` |
+| `--test library` | | Test framework: `auto_discover`, `rspec`, `test_unit`, `ex_unit`, `pytest`, `cargo_test` |
+| `--framework library` | | Application framework: `auto_discover`, `rails`, `padrino`, `rubygems`, `phoenix`, `elixir_mix`, `django`, `fast_api`, `python_package`, `rocket`, `rust_cargo` |
 | `--options=options` | | Additional options to pass to test command |
 | `--notifications library` | | Notification system: `auto_discover`, `osascript`, `terminal_notifier`, `notify_send`, `dunstify` |
 | `--mode theme` | | Image theme for notifications (see [Image Themes](#image-themes)) |
@@ -167,11 +172,11 @@ InfinityTest.setup do |config|
   config.gemset = 'my_project'
 
   # Test framework
-  # Options: :auto_discover, :rspec, :test_unit
+  # Options: :auto_discover, :rspec, :test_unit, :ex_unit, :pytest, :cargo_test
   config.test_framework = :rspec
 
   # Application framework
-  # Options: :auto_discover, :rails, :padrino, :rubygems
+  # Options: :auto_discover, :rails, :padrino, :rubygems, :phoenix, :elixir_mix, :django, :fast_api, :python_package, :rocket, :rust_cargo
   config.framework = :rails
 
   # File observer
@@ -324,6 +329,10 @@ Auto-detected when `test/` directory exists with `test_helper.rb` or `*_test.rb`
 config.test_framework = :test_unit
 ```
 
+### Other Test Frameworks (Experimental)
+
+See [Elixir Support](#experimental-elixir-support) for ExUnit and [Python Support](#experimental-python-support) for Pytest.
+
 ---
 
 ## Application Frameworks
@@ -358,6 +367,237 @@ Used for gem development and simple Ruby projects.
 
 ---
 
+## Experimental: Elixir Support
+
+> **Note:** Elixir support is experimental. Please report any issues.
+
+Infinity Test can watch Elixir projects and run ExUnit tests automatically.
+
+### ExUnit Test Framework
+
+Auto-detected when `test/` directory exists with `test_helper.exs` or `*_test.exs` files.
+
+```ruby
+config.test_framework = :ex_unit
+```
+
+### Phoenix Framework
+
+Auto-detected when `mix.exs` exists and `lib/*_web/` directory is present.
+
+**Watched directories:**
+- `lib/my_app/` → runs corresponding tests in `test/my_app/`
+- `lib/my_app_web/controllers/` → runs corresponding controller tests
+- `lib/my_app_web/live/` → runs corresponding LiveView tests
+- `test/` → runs the changed test file
+- `test/test_helper.exs` → runs all tests
+
+```ruby
+config.framework = :phoenix
+```
+
+### ElixirMix Framework
+
+For standard Elixir/Mix projects (non-Phoenix). Auto-detected when `mix.exs` exists.
+
+**Watched directories:**
+- `lib/` → runs corresponding tests
+- `test/` → runs the changed test file
+
+```ruby
+config.framework = :elixir_mix
+```
+
+### Elixir Configuration Example
+
+```ruby
+InfinityTest.setup do |config|
+  config.test_framework = :ex_unit
+  config.framework      = :phoenix  # or :elixir_mix
+  config.strategy       = :elixir_default
+  config.notifications  = :terminal_notifier
+end
+```
+
+---
+
+## Experimental: Python Support
+
+> **Note:** Python support is experimental. Please report any issues.
+
+Infinity Test can watch Python projects and run Pytest tests automatically.
+
+### Pytest Test Framework
+
+Auto-detected when `tests/` or `test/` directory exists with `test_*.py` or `*_test.py` files.
+
+```ruby
+config.test_framework = :pytest
+```
+
+**Output parsing:**
+- `5 passed` → success
+- `1 failed, 4 passed` → failure
+- `4 passed, 1 skipped` → pending
+
+### Django Framework
+
+Auto-detected when `manage.py` exists with Django imports.
+
+**Watched directories:**
+- Django app directories (containing `models.py`, `views.py`, or `apps.py`)
+- Each app's `tests/` directory or `tests.py` file
+- `conftest.py` → runs all tests
+
+```ruby
+config.framework = :django
+```
+
+### FastAPI Framework
+
+Auto-detected when `main.py` (or `app/main.py`, `src/main.py`) contains FastAPI imports. Ideal for ML model serving APIs.
+
+**Watched directories:**
+- `app/` → API application code
+- `routers/` → API route definitions
+- `api/` → API endpoints
+- `endpoints/` → endpoint handlers
+- `tests/` → test files
+
+```ruby
+config.framework = :fast_api
+```
+
+### PythonPackage Framework
+
+For standard Python packages. Auto-detected when `pyproject.toml`, `setup.py`, or `setup.cfg` exists.
+
+**Watched directories:**
+- `src/` → source code
+- `lib/` → library code
+- Package directories (containing `__init__.py`)
+- `tests/` or `test/` → test files
+
+```ruby
+config.framework = :python_package
+```
+
+### Python Configuration Example
+
+```ruby
+InfinityTest.setup do |config|
+  config.test_framework = :pytest
+  config.framework      = :fast_api  # or :django, :python_package
+  config.strategy       = :python_default
+  config.notifications  = :terminal_notifier
+end
+```
+
+### Python Project Structure Examples
+
+**FastAPI ML API:**
+```
+my_ml_api/
+├── app/
+│   ├── main.py          # from fastapi import FastAPI
+│   ├── models/          # ML models
+│   └── routers/         # API endpoints
+├── tests/
+│   ├── conftest.py
+│   └── test_api.py
+└── pyproject.toml
+```
+
+**Django ML Dashboard:**
+```
+my_dashboard/
+├── manage.py
+├── dashboard/           # Django app
+│   ├── models.py
+│   ├── views.py
+│   └── tests/
+├── ml_pipeline/         # Django app
+│   ├── models.py
+│   └── tests.py
+└── requirements.txt
+```
+
+---
+
+## Experimental: Rust Support
+
+> **Note:** Rust support is experimental. Please report any issues.
+
+Infinity Test can watch Rust projects and run `cargo test` automatically.
+
+### CargoTest Test Framework
+
+Auto-detected when `Cargo.toml` exists.
+
+```ruby
+config.test_framework = :cargo_test
+```
+
+**Output parsing:**
+- `5 passed; 0 failed; 0 ignored` → success
+- `3 passed; 2 failed; 0 ignored` → failure
+- `4 passed; 0 failed; 1 ignored` → pending
+
+### Rocket Framework
+
+Auto-detected when `Cargo.toml` contains `rocket` dependency. For Rocket web applications.
+
+**Watched directories:**
+- `src/*.rs` → runs tests matching the module name (e.g., `src/routes.rs` → `cargo test routes`)
+- `src/lib.rs` or `src/main.rs` → runs all tests
+- `tests/*.rs` → runs the specific integration test
+- `Cargo.toml` → runs all tests
+- `Rocket.toml` → runs all tests (if exists)
+
+```ruby
+config.framework = :rocket
+```
+
+### RustCargo Framework
+
+For standard Rust libraries and applications. Auto-detected when `Cargo.toml` exists (and no Rocket dependency).
+
+**Watched directories:**
+- `src/*.rs` → runs tests matching the module name
+- `tests/*.rs` → runs the specific integration test
+- `Cargo.toml` → runs all tests
+
+```ruby
+config.framework = :rust_cargo
+```
+
+### Rust Configuration Example
+
+```ruby
+InfinityTest.setup do |config|
+  config.test_framework = :cargo_test
+  config.framework      = :rust_cargo  # or :rocket
+  config.strategy       = :rust_default
+  config.notifications  = :terminal_notifier
+end
+```
+
+### Rust Project Structure Example
+
+```
+my_rust_project/
+├── Cargo.toml
+├── src/
+│   ├── lib.rs           # Changes run all tests
+│   ├── user.rs          # Changes run `cargo test user`
+│   └── utils.rs         # Changes run `cargo test utils`
+└── tests/
+    ├── integration.rs   # Changes run `cargo test --test integration`
+    └── api_tests.rs     # Changes run `cargo test --test api_tests`
+```
+
+---
+
 ## Notifications
 
 Desktop notifications show test results with themed images.

data/TODO.markdown

@@ -1,29 +1,38 @@
 ## Todo
 
-Infinity test is a gem that watch files changes and run tests.
-
-That also can run with different ruby versions all test suite or only that file change (using rvm or
-rbenv), ruby default just run the test on the current ruby version.
-
-## What Needs to Be Done
-
-* ~~Make notifications work with Notifiers gem (remove growl and use the autodiscover from notifiers gem).~~ DONE
-* ~~Change .infinity_test to INFINITY_TEST~~ DONE
-* ~~Make Test::Unit to work (the infinity test to check test folder).~~ DONE
-* ~~Make RSpec work~~ DONE
-* ~~Finish RubyDefault strategy~~ DONE
-* ~~Finish RVM (running different versions - the user need to specify)~~ DONE
-* ~~Finish RbEnv (running different versions - the user need to specify)~~ DONE
-* Make callbacks work in the new structure (loading the infinity test file).
-* ~~Finish Gem autodiscover and its changes heuristics.~~ DONE
-* ~~Finish Rails autodiscover and its changes heuristics.~~ DONE
-* ~~Padrino autodiscover and its changes heuristics.~~ DONE
-* ~~Improve auto discover feature priorization subclasses for #run? method.~~ DONE
-* ~~Focus feature(fails, pass one file, run entire suite) with --focus (experimented feature)!~~ DONE
-* ~~Add post-run hooks to be added to the INFINITY_TEST file that run other things (coverage, code
-analysis, etc - see ideas)~~ DONE (via callbacks system)
-
-* ~~Give some ideas (write to a md file the ideas) about how to integrate the infinity test with AI tools/AI agents or
-even Claude code ... so ruby developers can see~~ DONE (see AI_INTEGRATION_IDEAS.md)
-
-* ~~Update HISTORY with all changes since last version.~~ DONE
+Potential improvements and features for Infinity Test.
+
+## Next Steps
+
+### High Priority
+
+* Replace Hike gem dependency (last updated 12 years ago) with a simple built-in file finder
+* Add support for notification timeout/duration (use alerter for macOS, notify-send -t for Linux)
+* Add Minitest as explicit test framework option (currently uses test_unit)
+
+### Features
+
+* Add `--watch-only` option to specify specific directories to watch
+* Add `--ignore` CLI option to ignore specific files/patterns
+* Support for custom file extensions beyond .rb (e.g., .rake, .erb with embedded Ruby)
+* Add `--fail-fast` option to stop on first failure
+
+### Developer Experience
+
+* Add `--dry-run` option to show what command would be executed without running
+* Add `--debug` flag for troubleshooting file watching issues
+* Improve error messages when test framework is not found
+* Add startup banner showing detected configuration (framework, test lib, ruby strategy)
+
+### Integrations
+
+* Add GitHub Actions workflow template for CI
+* Add hook system for pre/post test execution scripts
+* Support for Docker-based Ruby version testing
+* Integration with code coverage tools (SimpleCov reporting)
+
+### Documentation
+
+* Add more examples to wiki for common use cases
+* Add troubleshooting guide
+* Add migration guide from Guard/Autotest

data/lib/infinity_test/core/auto_discover.rb

@@ -6,9 +6,9 @@ module InfinityTest
       # Priority order for auto discovery (higher priority first)
       # More specific libraries should be checked before generic ones
       PRIORITY = {
-        strategy: [:rvm, :rbenv, :ruby_default],
-        framework: [:rails, :padrino, :rubygems],
-        test_framework: [:rspec, :test_unit]
+        strategy: [:rvm, :rbenv, :elixir_default, :python_default, :rust_default, :ruby_default],
+        framework: [:rails, :padrino, :phoenix, :elixir_mix, :django, :fast_api, :python_package, :rocket, :rust_cargo, :rubygems],
+        test_framework: [:rspec, :test_unit, :ex_unit, :pytest, :cargo_test]
       }.freeze
 
       def initialize(base)

data/lib/infinity_test/core/command_runner.rb

@@ -1,3 +1,5 @@
+require 'pty'
+
 module InfinityTest
   module Core
     class CommandRunner < String
@@ -10,52 +12,26 @@ module InfinityTest
       end
 
       def run!
-        SynchronizeStdout.new do
-          open("| #{@command}", "r") do |file|
-            @command_output = CommandOutput.new(file)
-            @command_output.puts
-          end
-        end
-
-        @command_output.stdout
-      end
-    end
-
-    class CommandOutput
-      def initialize(file)
-        @file    = file
-        @results = []
-        @line    = []
-      end
-
-      def puts
-        until @file.eof? do
-          test_line = @file.getc or break
-          print(test_line)
-          @line.push(test_line)
-          if test_line == ?\n
-            # @results.push(yarv? ? @line.join : @line.pack('c*'))
-            @results.push(@line.join)
-            @line.clear
-          end
-        end
-      end
-
-      def stdout
-        @results.join
-      end
-    end
-
-    class SynchronizeStdout
-      def initialize
-        old_sync     = $stdout.sync
+        output = []
+        old_sync = $stdout.sync
         $stdout.sync = true
 
         begin
-          yield
+          PTY.spawn(@command) do |stdout, _stdin, _pid|
+            stdout.each_char do |char|
+              print char
+              output << char
+            end
+          end
+        rescue PTY::ChildExited
+          # Command finished
+        rescue Errno::EIO
+          # End of output
         ensure
           $stdout.sync = old_sync
         end
+
+        output.join
       end
     end
   end

data/lib/infinity_test/core/continuous_test_server.rb

@@ -10,10 +10,28 @@ module InfinityTest
       end
 
       def start
+        print_banner
         run_strategy unless just_watch
         start_observer
       end
 
+      # Print startup banner showing detected configuration.
+      # Only shows when verbose mode is enabled.
+      #
+      def print_banner
+        return unless Base.verbose?
+
+        puts "\e[96m"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        puts "  InfinityTest - To Infinity and Beyond!"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
+        puts "  Framework:      #{base.framework}"
+        puts "  Test Framework: #{base.test_framework}"
+        puts "  Strategy:       #{base.strategy}"
+        puts "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\e[0m"
+        puts
+      end
+
       # Run strategy based on the choosed ruby strategy.
       #
       def run_strategy

data/lib/infinity_test/core/version.rb

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

data/lib/infinity_test/framework/base.rb

@@ -52,6 +52,42 @@ module InfinityTest
         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