infinity_test 1.0.3 → 2.0.0.rc2

data/spec/infinity_test/framework/django_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Django do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'tests', test_helper_file: 'tests/conftest.py') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Django.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(subject).to receive(:watch_django_apps)
+          allow(File).to receive(:directory?).with('tests').and_return(true)
+          allow(File).to receive(:exist?).with('tests/conftest.py').and_return(true)
+        end
+
+        it "adds heuristics for django apps, test, and conftest" do
+          expect(subject).to receive(:watch_django_apps)
+          expect(observer).to receive(:watch_dir).with('tests', :py)
+          expect(observer).to receive(:watch).with('tests/conftest.py')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .py extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          expect(hike).to receive(:append_extension).with('.py')
+          expect(hike).to receive(:append_path).with('tests')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe "#watch_django_apps" do
+        context "when Django apps exist" do
+          before do
+            allow(Dir).to receive(:glob).with('*').and_return(['myapp', 'accounts', 'tests'])
+            allow(File).to receive(:directory?).with('myapp').and_return(true)
+            allow(File).to receive(:directory?).with('accounts').and_return(true)
+            allow(File).to receive(:directory?).with('tests').and_return(true)
+            allow(File).to receive(:exist?).with('myapp/models.py').and_return(true)
+            allow(File).to receive(:exist?).with('myapp/views.py').and_return(false)
+            allow(File).to receive(:exist?).with('myapp/apps.py').and_return(false)
+            allow(File).to receive(:exist?).with('accounts/models.py').and_return(false)
+            allow(File).to receive(:exist?).with('accounts/views.py').and_return(true)
+            allow(File).to receive(:exist?).with('accounts/apps.py').and_return(false)
+          end
+
+          it "watches Django app directories" do
+            expect(observer).to receive(:watch_dir).with('myapp', :py)
+            expect(observer).to receive(:watch_dir).with('accounts', :py)
+            subject.watch_django_apps
+          end
+        end
+      end
+
+      describe ".run?" do
+        context "when manage.py exists with Django" do
+          before do
+            allow(File).to receive(:exist?).with('manage.py').and_return(true)
+            allow(File).to receive(:read).with('manage.py').and_return("os.environ.setdefault('DJANGO_SETTINGS_MODULE'")
+          end
+
+          it "returns true" do
+            expect(Django).to be_run
+          end
+        end
+
+        context "when manage.py does not exist" do
+          before do
+            allow(File).to receive(:exist?).with('manage.py').and_return(false)
+          end
+
+          it "returns false" do
+            expect(Django).not_to be_run
+          end
+        end
+
+        context "when manage.py exists but is not Django" do
+          before do
+            allow(File).to receive(:exist?).with('manage.py').and_return(true)
+            allow(File).to receive(:read).with('manage.py').and_return("print('hello')")
+          end
+
+          it "returns false" do
+            expect(Django).not_to be_run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/elixir_mix_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe ElixirMix do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'test', test_helper_file: 'test/test_helper.exs') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { ElixirMix.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        it "adds heuristics for lib, test, and test_helper" do
+          expect(observer).to receive(:watch_dir).with(:lib, :ex)
+          expect(observer).to receive(:watch_dir).with('test', :exs)
+          expect(observer).to receive(:watch).with('test/test_helper.exs')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .exs extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          expect(hike).to receive(:append_extension).with('.exs')
+          expect(hike).to receive(:append_path).with('test')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if there is a mix.exs in the user current dir" do
+          expect(File).to receive(:exist?).with('mix.exs').and_return(true)
+          expect(ElixirMix).to be_run
+        end
+
+        it "returns false if there is no mix.exs in the user current dir" do
+          expect(File).to receive(:exist?).with('mix.exs').and_return(false)
+          expect(ElixirMix).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/fast_api_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe FastApi do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'tests', test_helper_file: 'tests/conftest.py') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { FastApi.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(subject).to receive(:watch_fastapi_dirs)
+          allow(File).to receive(:exist?).with('tests/conftest.py').and_return(true)
+        end
+
+        it "adds heuristics for fastapi dirs, test, and conftest" do
+          expect(subject).to receive(:watch_fastapi_dirs)
+          expect(observer).to receive(:watch_dir).with('tests', :py)
+          expect(observer).to receive(:watch).with('tests/conftest.py')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .py extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          expect(hike).to receive(:append_extension).with('.py')
+          expect(hike).to receive(:append_path).with('tests')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe "#watch_fastapi_dirs" do
+        context "when app directory exists" do
+          before do
+            allow(File).to receive(:directory?).with('app').and_return(true)
+            allow(File).to receive(:directory?).with('src').and_return(false)
+            allow(File).to receive(:directory?).with('routers').and_return(false)
+            allow(File).to receive(:directory?).with('api').and_return(false)
+            allow(File).to receive(:directory?).with('endpoints').and_return(false)
+            allow(File).to receive(:directory?).with('.').and_return(true)
+            allow(Dir).to receive(:glob).with('*.py').and_return(['main.py'])
+            allow(Dir).to receive(:glob).with('app/**/*.py').and_return(['app/main.py'])
+            allow(Dir).to receive(:glob).with('./**/*.py').and_return(['main.py'])
+          end
+
+          it "watches the app directory" do
+            expect(observer).to receive(:watch_dir).with('app', :py)
+            expect(observer).to receive(:watch_dir).with('.', :py)
+            subject.watch_fastapi_dirs
+          end
+        end
+      end
+
+      describe ".run?" do
+        context "when app/main.py exists with FastAPI" do
+          before do
+            allow(File).to receive(:exist?).with('app/main.py').and_return(true)
+            allow(File).to receive(:read).with('app/main.py').and_return('from fastapi import FastAPI')
+          end
+
+          it "returns true" do
+            expect(FastApi).to be_run
+          end
+        end
+
+        context "when main.py exists with FastAPI" do
+          before do
+            allow(File).to receive(:exist?).with('app/main.py').and_return(false)
+            allow(File).to receive(:exist?).with('main.py').and_return(true)
+            allow(File).to receive(:read).with('main.py').and_return('app = FastAPI()')
+          end
+
+          it "returns true" do
+            expect(FastApi).to be_run
+          end
+        end
+
+        context "when no FastAPI project" do
+          before do
+            allow(File).to receive(:exist?).with('app/main.py').and_return(false)
+            allow(File).to receive(:exist?).with('main.py').and_return(false)
+            allow(File).to receive(:exist?).with('src/main.py').and_return(false)
+          end
+
+          it "returns false" do
+            expect(FastApi).not_to be_run
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/padrino_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Padrino do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'spec') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Padrino.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        it "watches lib, test_dir, and test_helper_file" do
+          allow(File).to receive(:directory?).with('app').and_return(false)
+
+          expect(observer).to receive(:watch_dir).with(:lib)
+          expect(observer).to receive(:watch_dir).with('spec')
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+
+          expect { subject.heuristics }.to_not raise_exception
+        end
+
+        it "auto-discovers app directories containing ruby files" do
+          allow(File).to receive(:directory?).with('app').and_return(true)
+          allow(Dir).to receive(:glob).with('app/*').and_return(['app/models', 'app/views', 'app/components'])
+          allow(File).to receive(:directory?).with('app/models').and_return(true)
+          allow(File).to receive(:directory?).with('app/views').and_return(true)
+          allow(File).to receive(:directory?).with('app/components').and_return(true)
+          allow(Dir).to receive(:glob).with('app/models/**/*.rb').and_return(['app/models/user.rb'])
+          allow(Dir).to receive(:glob).with('app/views/**/*.rb').and_return([])
+          allow(Dir).to receive(:glob).with('app/components/**/*.rb').and_return(['app/components/button.rb'])
+
+          # Should watch models and components (have .rb files), skip views (no .rb files)
+          expect(observer).to receive(:watch_dir).with('app/models')
+          expect(observer).to receive(:watch_dir).with('app/components')
+          expect(observer).to receive(:watch_dir).with(:lib)
+          expect(observer).to receive(:watch_dir).with('spec')
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if config/apps.rb exists" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/apps.rb')).and_return(true)
+          expect(Padrino).to be_run
+        end
+
+        it "returns false if config/apps.rb does not exist" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/apps.rb')).and_return(false)
+          expect(Padrino).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/phoenix_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Phoenix do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'test', test_helper_file: 'test/test_helper.exs') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Phoenix.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(subject).to receive(:watch_lib_dirs)
+        end
+
+        it "adds heuristics for lib dirs, test, and test_helper" do
+          expect(subject).to receive(:watch_lib_dirs)
+          expect(observer).to receive(:watch_dir).with('test', :exs)
+          expect(observer).to receive(:watch).with('test/test_helper.exs')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .exs extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          expect(hike).to receive(:append_extension).with('.exs')
+          expect(hike).to receive(:append_path).with('test')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe "#watch_lib_dirs" do
+        context "when lib directory exists with subdirectories" do
+          before do
+            allow(File).to receive(:directory?).with('lib').and_return(true)
+            allow(Dir).to receive(:glob).with('lib/*').and_return(['lib/my_app', 'lib/my_app_web'])
+            allow(File).to receive(:directory?).with('lib/my_app').and_return(true)
+            allow(File).to receive(:directory?).with('lib/my_app_web').and_return(true)
+            allow(Dir).to receive(:glob).with('lib/my_app/**/*.ex').and_return(['lib/my_app/accounts.ex'])
+            allow(Dir).to receive(:glob).with('lib/my_app_web/**/*.ex').and_return(['lib/my_app_web/controllers/page_controller.ex'])
+          end
+
+          it "watches all lib subdirectories with .ex files" do
+            expect(observer).to receive(:watch_dir).with('lib/my_app', :ex)
+            expect(observer).to receive(:watch_dir).with('lib/my_app_web', :ex)
+            subject.watch_lib_dirs
+          end
+        end
+
+        context "when lib directory does not exist" do
+          before do
+            allow(File).to receive(:directory?).with('lib').and_return(false)
+          end
+
+          it "does nothing" do
+            expect(observer).not_to receive(:watch_dir)
+            subject.watch_lib_dirs
+          end
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if mix.exs exists and has lib/*_web directory" do
+          expect(File).to receive(:exist?).with('mix.exs').and_return(true)
+          expect(Dir).to receive(:glob).with('lib/*_web').and_return(['lib/my_app_web'])
+          expect(Phoenix).to be_run
+        end
+
+        it "returns false if mix.exs does not exist" do
+          expect(File).to receive(:exist?).with('mix.exs').and_return(false)
+          expect(Phoenix).not_to be_run
+        end
+
+        it "returns false if no lib/*_web directory exists" do
+          expect(File).to receive(:exist?).with('mix.exs').and_return(true)
+          expect(Dir).to receive(:glob).with('lib/*_web').and_return([])
+          expect(Phoenix).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/python_package_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe PythonPackage do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'tests', test_helper_file: 'tests/conftest.py') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { PythonPackage.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(subject).to receive(:watch_python_dirs)
+          allow(File).to receive(:exist?).with('tests/conftest.py').and_return(true)
+        end
+
+        it "adds heuristics for python dirs, test, and conftest" do
+          expect(subject).to receive(:watch_python_dirs)
+          expect(observer).to receive(:watch_dir).with('tests', :py)
+          expect(observer).to receive(:watch).with('tests/conftest.py')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .py extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          expect(hike).to receive(:append_extension).with('.py')
+          expect(hike).to receive(:append_path).with('tests')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe "#watch_python_dirs" do
+        context "when src directory exists" do
+          before do
+            allow(File).to receive(:directory?).with('src').and_return(true)
+            allow(File).to receive(:directory?).with('lib').and_return(false)
+            allow(Dir).to receive(:glob).with('*/__init__.py').and_return([])
+            allow(Dir).to receive(:glob).with('src/**/*.py').and_return(['src/mypackage/utils.py'])
+          end
+
+          it "watches the src directory" do
+            expect(observer).to receive(:watch_dir).with('src', :py)
+            subject.watch_python_dirs
+          end
+        end
+
+        context "when package directory with __init__.py exists" do
+          before do
+            allow(File).to receive(:directory?).with('src').and_return(false)
+            allow(File).to receive(:directory?).with('lib').and_return(false)
+            allow(Dir).to receive(:glob).with('*/__init__.py').and_return(['mypackage/__init__.py'])
+            allow(File).to receive(:directory?).with('mypackage').and_return(true)
+            allow(Dir).to receive(:glob).with('mypackage/**/*.py').and_return(['mypackage/utils.py'])
+          end
+
+          it "watches the package directory" do
+            expect(observer).to receive(:watch_dir).with('mypackage', :py)
+            subject.watch_python_dirs
+          end
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if pyproject.toml exists" do
+          expect(File).to receive(:exist?).with('pyproject.toml').and_return(true)
+          expect(PythonPackage).to be_run
+        end
+
+        it "returns true if setup.py exists" do
+          expect(File).to receive(:exist?).with('pyproject.toml').and_return(false)
+          expect(File).to receive(:exist?).with('setup.py').and_return(true)
+          expect(PythonPackage).to be_run
+        end
+
+        it "returns true if setup.cfg exists" do
+          expect(File).to receive(:exist?).with('pyproject.toml').and_return(false)
+          expect(File).to receive(:exist?).with('setup.py').and_return(false)
+          expect(File).to receive(:exist?).with('setup.cfg').and_return(true)
+          expect(PythonPackage).to be_run
+        end
+
+        it "returns false if no Python package files exist" do
+          expect(File).to receive(:exist?).with('pyproject.toml').and_return(false)
+          expect(File).to receive(:exist?).with('setup.py').and_return(false)
+          expect(File).to receive(:exist?).with('setup.cfg').and_return(false)
+          expect(PythonPackage).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/rails_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Rails do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'spec') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Rails.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        it "watches lib, test_dir, and test_helper_file" do
+          allow(File).to receive(:directory?).with('app').and_return(false)
+
+          expect(observer).to receive(:watch_dir).with(:lib)
+          expect(observer).to receive(:watch_dir).with('spec')
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+
+          expect { subject.heuristics }.to_not raise_exception
+        end
+
+        it "auto-discovers app directories containing ruby files" do
+          allow(File).to receive(:directory?).with('app').and_return(true)
+          allow(Dir).to receive(:glob).with('app/*').and_return(['app/models', 'app/views', 'app/components'])
+          allow(File).to receive(:directory?).with('app/models').and_return(true)
+          allow(File).to receive(:directory?).with('app/views').and_return(true)
+          allow(File).to receive(:directory?).with('app/components').and_return(true)
+          allow(Dir).to receive(:glob).with('app/models/**/*.rb').and_return(['app/models/user.rb'])
+          allow(Dir).to receive(:glob).with('app/views/**/*.rb').and_return([])
+          allow(Dir).to receive(:glob).with('app/components/**/*.rb').and_return(['app/components/button.rb'])
+
+          # Should watch models and components (have .rb files), skip views (no .rb files)
+          expect(observer).to receive(:watch_dir).with('app/models')
+          expect(observer).to receive(:watch_dir).with('app/components')
+          expect(observer).to receive(:watch_dir).with(:lib)
+          expect(observer).to receive(:watch_dir).with('spec')
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if config/environment.rb exists" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/environment.rb')).and_return(true)
+          expect(Rails).to be_run
+        end
+
+        it "returns false if config/environment.rb does not exist" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/environment.rb')).and_return(false)
+          expect(Rails).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/rocket_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Rocket do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework', test_dir: 'tests', test_helper_file: 'Cargo.toml') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Rocket.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(File).to receive(:directory?).with('tests').and_return(true)
+          allow(File).to receive(:exist?).with('Rocket.toml').and_return(true)
+        end
+
+        it "adds heuristics for src, tests, Cargo.toml, and Rocket.toml" do
+          expect(observer).to receive(:watch_dir).with(:src, :rs)
+          expect(observer).to receive(:watch_dir).with('tests', :rs)
+          expect(observer).to receive(:watch).with('Cargo.toml')
+          expect(observer).to receive(:watch).with('Rocket.toml')
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe "#heuristics!" do
+        it "appends .rs extension to hike" do
+          hike = double('Hike')
+          allow(subject).to receive(:hike).and_return(hike)
+          allow(File).to receive(:directory?).with('tests').and_return(true)
+          expect(hike).to receive(:append_extension).with('.rs')
+          expect(hike).to receive(:append_path).with('tests')
+          allow(subject).to receive(:heuristics)
+          subject.heuristics!
+        end
+      end
+
+      describe "#run_module_tests" do
+        let(:changed_file) { double('ChangedFile', name: 'src/routes.rs', path: 'routes') }
+
+        it "runs tests matching the module name" do
+          expect(continuous_test_server).to receive(:rerun_strategy).with('routes')
+          subject.run_module_tests(changed_file)
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if Cargo.toml exists with rocket dependency" do
+          expect(File).to receive(:exist?).with('Cargo.toml').and_return(true)
+          expect(File).to receive(:exist?).with('Cargo.toml').and_return(true)
+          expect(File).to receive(:read).with('Cargo.toml').and_return('rocket = "0.5"')
+          expect(Rocket).to be_run
+        end
+
+        it "returns false if Cargo.toml does not exist" do
+          expect(File).to receive(:exist?).with('Cargo.toml').and_return(false)
+          expect(Rocket).not_to be_run
+        end
+
+        it "returns false if Cargo.toml does not contain rocket" do
+          expect(File).to receive(:exist?).with('Cargo.toml').and_return(true)
+          expect(File).to receive(:exist?).with('Cargo.toml').and_return(true)
+          expect(File).to receive(:read).with('Cargo.toml').and_return('[dependencies]')
+          expect(Rocket).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/rubygems_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Rubygems do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Rubygems.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        it "adds heuristics" do
+          expect(observer).to receive(:watch_dir).exactly(2)
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+          expect(test_framework).to receive(:test_dir)
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if there is a .gemspec in the user current dir" do
+          expect(Dir).to receive(:[]).with('*.gemspec').and_return(['infinity_test.gemspec'])
+          expect(Rubygems).to be_run
+        end
+
+        it "returns false if there is no .gemspec in the user current dir" do
+          expect(Dir).to receive(:[]).with('*.gemspec').and_return([])
+          expect(Rubygems).not_to be_run
+        end
+      end
+    end
+  end
+end