infinity_test 2.0.0.rc1 → 2.0.0.rc2

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

@@ -4,18 +4,40 @@ module InfinityTest
   module Framework
     describe Rails do
       let(:observer) { double('Observer') }
-      let(:test_framework) { double('TestFramework') }
+      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 "adds heuristics" do
-          # 6 watch_dir calls: models, controllers, helpers, mailers, jobs, lib, test_dir
-          expect(observer).to receive(:watch_dir).exactly(7)
-          # 1 watch call for test_helper_file
+        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(test_framework).to receive(:test_dir)
+
+          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

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/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/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

@@ -44,8 +44,25 @@ module InfinityTest
           allow(Core::Base).to receive(:rubies).and_return(['2.7.0', '3.0.0'])
         end
 
-        it 'returns the command for multiple ruby versions' do
-          expect(subject.run!).to eq 'RBENV_VERSION=2.7.0 ruby -S rspec spec && RBENV_VERSION=3.0.0 ruby -S rspec spec'
+        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

data/spec/infinity_test/strategy/ruby_default_spec.rb

@@ -23,8 +23,25 @@ module InfinityTest
       describe '#run!' do
         before { base.test_framework = :rspec }
 
-        it 'returns the command' do
-          expect(subject.run!).to eq 'ruby -S rspec spec'
+        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

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

@@ -50,17 +50,34 @@ module InfinityTest
           allow(Core::Base).to receive(:gemset).and_return(nil)
         end
 
-        it 'returns the command for multiple ruby versions' do
-          expect(subject.run!).to eq 'rvm 2.7.0 do ruby -S rspec spec && rvm 3.0.0 do ruby -S rspec spec'
+        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 'with gemset' do
+        context 'without bundler' do
           before do
-            allow(Core::Base).to receive(:gemset).and_return('infinity_test')
+            allow(Core::Base).to receive(:using_bundler?).and_return(false)
           end
 
-          it 'includes gemset in the command' do
-            expect(subject.run!).to eq 'rvm 2.7.0@infinity_test do ruby -S rspec spec && rvm 3.0.0@infinity_test do ruby -S rspec spec'
+          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