infinity_test 1.0.3 → 2.0.0.rc2

data/spec/infinity_test/framework/rust_cargo_spec.rb

@@ -0,0 +1,94 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe RustCargo 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 { RustCargo.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        before do
+          allow(File).to receive(:directory?).with('tests').and_return(true)
+        end
+
+        it "adds heuristics for src, tests, and Cargo.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 { 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/user.rs', path: 'user') }
+
+        it "runs tests matching the module name" do
+          expect(continuous_test_server).to receive(:rerun_strategy).with('user')
+          subject.run_module_tests(changed_file)
+        end
+
+        context "when lib.rs is changed" do
+          let(:lib_file) { double('ChangedFile', name: 'src/lib.rs', path: 'lib') }
+
+          it "runs all tests" do
+            expect(subject).to receive(:run_all)
+            subject.run_module_tests(lib_file)
+          end
+        end
+
+        context "when main.rs is changed" do
+          let(:main_file) { double('ChangedFile', name: 'src/main.rs', path: 'main') }
+
+          it "runs all tests" do
+            expect(subject).to receive(:run_all)
+            subject.run_module_tests(main_file)
+          end
+        end
+      end
+
+      describe "#run_integration_test" do
+        let(:changed_file) { double('ChangedFile', name: 'tests/integration_test.rs') }
+
+        it "runs the specific integration test" do
+          expect(continuous_test_server).to receive(:rerun_strategy).with('--test integration_test')
+          subject.run_integration_test(changed_file)
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if Cargo.toml exists and is not a Rocket project" 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(RustCargo).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(RustCargo).not_to be_run
+        end
+
+        it "returns false if it is a Rocket project" 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(RustCargo).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/observer/base_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Observer
+    describe Base do
+      let(:continuous_server) { double }
+      subject { Base.new(continuous_server) }
+
+      describe "#initialize" do
+        it "sets the continuous_test_server" do
+          expect(subject.continuous_test_server).to eq(continuous_server)
+        end
+      end
+
+      describe "#watch" do
+        it "raises NotImplementedError" do
+          expect { subject.watch('pattern') {} }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe "#watch_dir" do
+        it "raises NotImplementedError" do
+          expect { subject.watch_dir(:lib, :rb) {} }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe "#start" do
+        it "raises NotImplementedError" do
+          expect { subject.start }.to raise_error(NotImplementedError)
+        end
+      end
+
+      describe "#start!" do
+        it "calls signal and start" do
+          expect(subject).to receive(:signal)
+          expect(subject).to receive(:start)
+          subject.start!
+        end
+      end
+
+      describe "#signal" do
+        it "traps INT signal" do
+          expect(Signal).to receive(:trap).with('INT')
+          subject.signal
+        end
+
+        context "interrupt handling logic" do
+          let(:handler) do
+            handler_block = nil
+            allow(Signal).to receive(:trap) { |_, &block| handler_block = block }
+            subject.signal
+            handler_block
+          end
+
+          it "shows warning on first interrupt" do
+            expect(subject).to receive(:puts).with(" Are you sure? :S ... Interrupt a second time to quit!")
+            handler.call
+            expect(subject.instance_variable_get(:@interrupt_at)).to be_within(1).of(Time.now)
+          end
+
+          it "exits on second interrupt within 2 seconds" do
+            subject.instance_variable_set(:@interrupt_at, Time.now)
+            expect(subject).to receive(:puts).with(" To Infinity and Beyond!")
+            expect(subject).to receive(:exit)
+            handler.call
+          end
+
+          it "resets timer if second interrupt is after 2 seconds" do
+            subject.instance_variable_set(:@interrupt_at, Time.now - 3)
+            expect(subject).to receive(:puts).with(" Are you sure? :S ... Interrupt a second time to quit!")
+            handler.call
+            expect(subject.instance_variable_get(:@interrupt_at)).to be_within(1).of(Time.now)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/observer/filewatcher_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Observer
+    describe Filewatcher do
+      let(:continuous_server) { double }
+      subject { Filewatcher.new(continuous_server) }
+
+      it_should_behave_like 'an infinity test observer'
+
+      describe "#patterns" do
+        it "starts as an empty hash" do
+          expect(subject.patterns).to eq({})
+        end
+      end
+
+      describe "#watch_paths" do
+        it "starts as an empty array" do
+          expect(subject.watch_paths).to eq([])
+        end
+      end
+
+      describe "#watch" do
+        it "adds a pattern with its block to patterns" do
+          block = proc { |file| file }
+          subject.watch('lib/(.*)\.rb', &block)
+          expect(subject.patterns.keys.first).to be_a(Regexp)
+          expect(subject.patterns.values.first).to eq(block)
+        end
+      end
+
+      describe "#watch_dir" do
+        it "adds a glob pattern to watch_paths" do
+          subject.watch_dir(:spec)
+          expect(subject.watch_paths).to include('spec/**/*.rb')
+        end
+
+        it "adds a pattern to patterns" do
+          subject.watch_dir(:spec)
+          expect(subject.patterns.keys.first.source).to eq('^spec/*/(.*).rb')
+        end
+
+        it "accepts a custom extension" do
+          subject.watch_dir(:spec, :py)
+          expect(subject.watch_paths).to include('spec/**/*.py')
+          expect(subject.patterns.keys.first.source).to eq('^spec/*/(.*).py')
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/observer/listen_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Observer
+    describe Listen do
+      let(:continuous_server) { double }
+      subject { Listen.new(continuous_server) }
+
+      it_should_behave_like 'an infinity test observer'
+
+      describe "#patterns" do
+        it "starts as an empty hash" do
+          expect(subject.patterns).to eq({})
+        end
+      end
+
+      describe "#directories" do
+        it "starts as an empty array" do
+          expect(subject.directories).to eq([])
+        end
+      end
+
+      describe "#watch" do
+        it "adds a pattern with its block to patterns" do
+          block = proc { |file| file }
+          subject.watch('lib/(.*)\.rb', &block)
+          expect(subject.patterns.keys.first).to be_a(Regexp)
+          expect(subject.patterns.values.first).to eq(block)
+        end
+      end
+
+      describe "#watch_dir" do
+        it "adds a pattern to patterns" do
+          subject.watch_dir(:spec)
+          expect(subject.patterns.keys.first.source).to eq('^spec/*/(.*).rb')
+        end
+
+        it "adds the directory to directories" do
+          subject.watch_dir(:spec)
+          expect(subject.directories).to include('spec')
+        end
+
+        it "accepts a custom extension" do
+          subject.watch_dir(:spec, :py)
+          expect(subject.patterns.keys.first.source).to eq('^spec/*/(.*).py')
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/{builder_spec.rb → strategy/base_spec.rb}

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 module InfinityTest
-  describe Builder do
-
+  describe Base do
   end
 end

data/spec/infinity_test/strategy/elixir_default_spec.rb

@@ -0,0 +1,46 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe ElixirDefault do
+      let(:base) { BaseFixture.new }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { ElixirDefault.new(continuous_test_server) }
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        it "returns true when mix.exs exists" do
+          allow(File).to receive(:exist?).with('mix.exs').and_return(true)
+          expect(ElixirDefault).to be_run
+        end
+
+        it "returns false when mix.exs does not exist" do
+          allow(File).to receive(:exist?).with('mix.exs').and_return(false)
+          expect(ElixirDefault).not_to be_run
+        end
+      end
+
+      describe '#run!' do
+        before { base.test_framework = :ex_unit }
+
+        it 'returns the mix test command' do
+          expect(subject.run!).to eq 'mix test test'
+        end
+
+        context 'with specific options' do
+          before do
+            Core::Base.specific_options = '--trace'
+          end
+
+          after do
+            Core::Base.specific_options = ''
+          end
+
+          it 'includes the options' do
+            expect(subject.run!).to eq 'mix test test --trace'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/strategy/python_default_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe PythonDefault do
+      let(:base) { BaseFixture.new }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { PythonDefault.new(continuous_test_server) }
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        it "returns true when pyproject.toml exists" do
+          allow(File).to receive(:exist?).with('pyproject.toml').and_return(true)
+          expect(PythonDefault).to be_run
+        end
+
+        it "returns true when setup.py exists" do
+          allow(File).to receive(:exist?).with('pyproject.toml').and_return(false)
+          allow(File).to receive(:exist?).with('setup.py').and_return(true)
+          expect(PythonDefault).to be_run
+        end
+
+        it "returns false when no Python package files exist" do
+          allow(File).to receive(:exist?).with('pyproject.toml').and_return(false)
+          allow(File).to receive(:exist?).with('setup.py').and_return(false)
+          allow(File).to receive(:exist?).with('setup.cfg').and_return(false)
+          expect(PythonDefault).not_to be_run
+        end
+      end
+
+      describe '#run!' do
+        before { base.test_framework = :pytest }
+
+        it 'returns the pytest command' do
+          allow(File).to receive(:exist?).with('tests').and_return(true)
+          expect(subject.run!).to eq 'pytest tests'
+        end
+
+        context 'with specific options' do
+          before do
+            Core::Base.specific_options = '-v --tb=short'
+          end
+
+          after do
+            Core::Base.specific_options = ''
+          end
+
+          it 'includes the options' do
+            allow(File).to receive(:exist?).with('tests').and_return(true)
+            expect(subject.run!).to eq 'pytest tests -v --tb=short'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/strategy/rbenv_spec.rb

@@ -0,0 +1,70 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe Rbenv do
+      let(:base) { BaseFixture.new(test_framework: :rspec) }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { Rbenv.new(continuous_test_server) }
+
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        let(:rbenv_dir) { File.expand_path('~/.rbenv') }
+
+        context "when rubies are specified" do
+          before do
+            allow(Core::Base).to receive(:rubies).and_return(['2.7.0', '3.0.0'])
+          end
+
+          it "returns true if the user has rbenv installed" do
+            expect(File).to receive(:exist?).with(rbenv_dir).and_return(true)
+            expect(Rbenv).to be_run
+          end
+
+          it "returns false if the user does not have rbenv installed" do
+            expect(File).to receive(:exist?).with(rbenv_dir).and_return(false)
+            expect(Rbenv).not_to be_run
+          end
+        end
+
+        context "when no rubies are specified" do
+          before do
+            allow(Core::Base).to receive(:rubies).and_return([])
+          end
+
+          it "returns false even if rbenv is installed" do
+            expect(Rbenv).not_to be_run
+          end
+        end
+      end
+
+      describe '#run!' do
+        before do
+          allow(Core::Base).to receive(:rubies).and_return(['2.7.0', '3.0.0'])
+        end
+
+        context 'with bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(true)
+            allow(File).to receive(:exist?).with('Gemfile').and_return(true)
+          end
+
+          it 'returns the command for multiple ruby versions with bundle exec' do
+            expect(subject.run!).to eq 'RBENV_VERSION=2.7.0 bundle exec rspec spec && RBENV_VERSION=3.0.0 bundle exec rspec spec'
+          end
+        end
+
+        context 'without bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(false)
+          end
+
+          it 'returns the command for multiple ruby versions without bundle exec' do
+            expect(subject.run!).to eq 'RBENV_VERSION=2.7.0 rspec spec && RBENV_VERSION=3.0.0 rspec spec'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/strategy/ruby_default_spec.rb

@@ -0,0 +1,49 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe RubyDefault do
+      let(:base) { BaseFixture.new }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { RubyDefault.new(continuous_test_server) }
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        it "returns true when no ruby versions are passed to run tests" do
+          allow(Core::Base).to receive(:rubies).and_return([])
+          expect(RubyDefault).to be_run
+        end
+
+        it "returns false when some ruby version is passed to run tests" do
+          allow(Core::Base).to receive(:rubies).and_return(['ree', 'jruby'])
+          expect(RubyDefault).not_to be_run
+        end
+      end
+
+      describe '#run!' do
+        before { base.test_framework = :rspec }
+
+        context 'with bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(true)
+            allow(File).to receive(:exist?).with('Gemfile').and_return(true)
+          end
+
+          it 'returns the command with bundle exec' do
+            expect(subject.run!).to eq 'bundle exec rspec spec'
+          end
+        end
+
+        context 'without bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(false)
+          end
+
+          it 'returns the command without bundle exec' do
+            expect(subject.run!).to eq 'rspec spec'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/strategy/rust_default_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe RustDefault do
+      let(:base) { BaseFixture.new }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { RustDefault.new(continuous_test_server) }
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        it "returns true when Cargo.toml exists" do
+          allow(File).to receive(:exist?).with('Cargo.toml').and_return(true)
+          expect(RustDefault).to be_run
+        end
+
+        it "returns false when Cargo.toml does not exist" do
+          allow(File).to receive(:exist?).with('Cargo.toml').and_return(false)
+          expect(RustDefault).not_to be_run
+        end
+      end
+
+      describe '#run!' do
+        before { base.test_framework = :cargo_test }
+
+        it 'returns the cargo test command' do
+          expect(subject.run!).to eq 'cargo test'
+        end
+
+        context 'with test files specified' do
+          before do
+            allow(continuous_test_server).to receive(:test_files).and_return('user')
+          end
+
+          it 'includes the test name' do
+            expect(subject.run!).to eq 'cargo test user'
+          end
+        end
+
+        context 'with specific options' do
+          before do
+            Core::Base.specific_options = '-- --nocapture'
+          end
+
+          after do
+            Core::Base.specific_options = ''
+          end
+
+          it 'includes the options' do
+            expect(subject.run!).to eq 'cargo test -- --nocapture'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/strategy/rvm_spec.rb

@@ -0,0 +1,86 @@
+require "spec_helper"
+
+module InfinityTest
+  module Strategy
+    describe Rvm do
+      let(:base) { BaseFixture.new(test_framework: :rspec) }
+      let(:continuous_test_server) { Core::ContinuousTestServer.new(base) }
+      subject { Rvm.new(continuous_test_server) }
+
+      it_should_behave_like 'a infinity test strategy'
+
+      describe ".run?" do
+        context "when rubies are specified" do
+          before do
+            allow(Core::Base).to receive(:rubies).and_return(['2.7.0', '3.0.0'])
+          end
+
+          it "returns true if the user has RVM installed in users home" do
+            expect(Rvm).to receive(:installed_users_home?).and_return(true)
+            expect(Rvm).to be_run
+          end
+
+          it "returns true if the user has RVM installed system wide" do
+            expect(Rvm).to receive(:installed_users_home?).and_return(false)
+            expect(Rvm).to receive(:installed_system_wide?).and_return(true)
+            expect(Rvm).to be_run
+          end
+
+          it "returns false if the user does not have RVM installed" do
+            expect(Rvm).to receive(:installed_users_home?).and_return(false)
+            expect(Rvm).to receive(:installed_system_wide?).and_return(false)
+            expect(Rvm).not_to be_run
+          end
+        end
+
+        context "when no rubies are specified" do
+          before do
+            allow(Core::Base).to receive(:rubies).and_return([])
+          end
+
+          it "returns false even if RVM is installed" do
+            expect(Rvm).not_to be_run
+          end
+        end
+      end
+
+      describe '#run!' do
+        before do
+          allow(Core::Base).to receive(:rubies).and_return(['2.7.0', '3.0.0'])
+          allow(Core::Base).to receive(:gemset).and_return(nil)
+        end
+
+        context 'with bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(true)
+            allow(File).to receive(:exist?).with('Gemfile').and_return(true)
+          end
+
+          it 'returns the command for multiple ruby versions with bundle exec' do
+            expect(subject.run!).to eq 'rvm 2.7.0 do bundle exec rspec spec && rvm 3.0.0 do bundle exec rspec spec'
+          end
+
+          context 'with gemset' do
+            before do
+              allow(Core::Base).to receive(:gemset).and_return('infinity_test')
+            end
+
+            it 'includes gemset in the command' do
+              expect(subject.run!).to eq 'rvm 2.7.0@infinity_test do bundle exec rspec spec && rvm 3.0.0@infinity_test do bundle exec rspec spec'
+            end
+          end
+        end
+
+        context 'without bundler' do
+          before do
+            allow(Core::Base).to receive(:using_bundler?).and_return(false)
+          end
+
+          it 'returns the command for multiple ruby versions without bundle exec' do
+            expect(subject.run!).to eq 'rvm 2.7.0 do rspec spec && rvm 3.0.0 do rspec spec'
+          end
+        end
+      end
+    end
+  end
+end