infinity_test 1.0.2 → 2.0.0.rc1

data/spec/infinity_test/core/base_spec.rb

@@ -0,0 +1,240 @@
+require "spec_helper"
+
+module InfinityTest
+  describe Base do
+    describe ".setup" do
+      it "yields self" do
+        Base.setup do |config|
+          expect(config).to be InfinityTest::Base
+        end
+      end
+    end
+
+    describe ".using_bundler?" do
+      it "returns the same bundler accessor" do
+        expect(Base.using_bundler?).to equal Base.bundler
+      end
+    end
+
+    describe "#verbose?" do
+      it "returns the same verbose accessor" do
+        expect(Base.verbose?).to equal Base.verbose
+      end
+    end
+
+    describe ".observer" do
+      it "has listen as default observer" do
+        expect(Base.observer).to equal :listen
+      end
+    end
+
+    describe ".ignore_test_files" do
+      it "does not have test files to ignore as default" do
+        expect(Base.ignore_test_files).to eql []
+      end
+    end
+
+    describe "#ignore_test_folders" do
+      it "does not ignore test folders as default" do
+        expect(Base.ignore_test_folders).to eql []
+      end
+    end
+
+    describe ".before" do
+      after { Base.clear_callbacks! }
+
+      it "creates before callback instance and pushes to the callback accessor" do
+        before_callback = Base.before(:all) { 'To Infinity and beyond!' }
+        expect(before_callback).to be_a Core::Callback
+        expect(before_callback.type).to eq :before
+        expect(before_callback.scope).to eq :all
+        expect(Base.callbacks).to include before_callback
+      end
+
+      it "defaults scope to :all" do
+        before_callback = Base.before { 'test' }
+        expect(before_callback.scope).to eq :all
+      end
+    end
+
+    describe ".after" do
+      after { Base.clear_callbacks! }
+
+      it "creates after callback instance and pushes to the callback accessor" do
+        after_callback = Base.after(:each_ruby) { 'done' }
+        expect(after_callback).to be_a Core::Callback
+        expect(after_callback.type).to eq :after
+        expect(after_callback.scope).to eq :each_ruby
+        expect(Base.callbacks).to include after_callback
+      end
+    end
+
+    describe ".run_before_callbacks" do
+      after { Base.clear_callbacks! }
+
+      it "runs all before callbacks for the given scope" do
+        results = []
+        Base.before(:all) { results << 'first' }
+        Base.before(:all) { results << 'second' }
+        Base.before(:each_ruby) { results << 'each_ruby' }
+
+        Base.run_before_callbacks(:all)
+        expect(results).to eq ['first', 'second']
+      end
+    end
+
+    describe ".run_after_callbacks" do
+      after { Base.clear_callbacks! }
+
+      it "runs all after callbacks for the given scope" do
+        results = []
+        Base.after(:all) { results << 'first' }
+        Base.after(:all) { results << 'second' }
+
+        Base.run_after_callbacks(:all)
+        expect(results).to eq ['first', 'second']
+      end
+    end
+
+    describe ".just_watch" do
+      it "defaults to false" do
+        expect(Base.just_watch).to eq false
+      end
+    end
+
+    describe ".notifications" do
+      it "sets the notification class accessor" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript)
+          expect(Base.notifications).to be :osascript
+        end
+      end
+
+      it "sets the images" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript) do
+            show_images :success_image => 'foo', :failure_image => 'bar', :pending_image => 'baz'
+          end
+        end
+        expect(Base.success_image).to eql 'foo'
+        expect(Base.failure_image).to eql 'bar'
+        expect(Base.pending_image).to eql 'baz'
+        Base.success_image = nil
+        Base.failure_image = nil
+        Base.pending_image = nil
+      end
+
+      it "sets the mode" do
+        silence_stream(STDOUT) do
+          Base.notifications(:osascript) do
+            show_images :mode => :mortal_kombat
+          end
+        end
+        expect(Base.mode).to be :mortal_kombat
+      end
+    end
+
+    describe ".use" do
+      before do
+        @old_rubies = Base.rubies
+        @old_specific_options = Base.specific_options
+        @test_framework = Base.test_framework
+        @framework = Base.framework
+        @verbose = Base.verbose
+        @gemset  = Base.gemset
+      end
+
+      after do
+        Base.rubies = @old_rubies
+        Base.specific_options = @old_specific_options
+        Base.test_framework = @test_framework
+        Base.framework = @framework
+        Base.verbose = @verbose
+        Base.gemset = @gemset
+      end
+
+      it "sets the rubies" do
+        silence_stream(STDOUT) do
+          Base.use :rubies => %w(foo bar)
+        end
+        expect(Base.rubies).to eql %w(foo bar)
+      end
+
+      it "sets the specific options" do
+        silence_stream(STDOUT) do
+          Base.use :specific_options => '-J -Ilib -Itest'
+        end
+        expect(Base.specific_options).to eql '-J -Ilib -Itest'
+      end
+
+      it "sets the test framework" do
+        silence_stream(STDOUT) do
+          Base.use :test_framework => :rspec
+        end
+        expect(Base.test_framework).to be :rspec
+      end
+
+      it "sets the app framework" do
+        silence_stream(STDOUT) do
+          Base.use :app_framework => :rails
+        end
+        expect(Base.framework).to be :rails
+      end
+
+      it "sets the verbose mode" do
+        silence_stream(STDOUT) do
+          Base.use :verbose => false
+        end
+        expect(Base.verbose).to equal false
+      end
+
+      it "sets the gemset" do
+        silence_stream(STDOUT) do
+          Base.use :gemset => 'infinity_test'
+        end
+        expect(Base.gemset).to eql 'infinity_test'
+      end
+    end
+
+    describe ".heuristics" do
+      it "accepts a block" do
+        expect { Base.heuristics {} }.to_not raise_exception
+      end
+    end
+
+    describe ".replace_patterns" do
+      it "accepts a block" do
+        expect { Base.replace_patterns {} }.to_not raise_exception
+      end
+    end
+
+    describe ".merge!" do
+      let(:options) { Object.new }
+      let(:configuration_merge) { Object.new }
+
+      it "calls merge on the configuration merge object" do
+        expect(ConfigurationMerge).to receive(:new).with(Core::Base, options).and_return(configuration_merge)
+        expect(configuration_merge).to receive(:merge!)
+        Core::Base.merge!(options)
+      end
+    end
+
+    describe ".clear" do
+      it "calls clear_terminal method" do
+        silence_stream(STDOUT) do
+          expect(Base).to receive(:clear_terminal).and_return(true)
+          Base.clear(:terminal)
+        end
+      end
+    end
+
+    describe ".clear_terminal" do
+      it "calls system clear" do
+        silence_stream(STDOUT) do
+          expect(Base).to receive(:system).with('clear').and_return(true)
+          Base.clear_terminal
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/callback_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe Callback do
+      describe '#initialize' do
+        it 'creates a before callback with default scope' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback.type).to eq :before
+          expect(callback.scope).to eq :all
+        end
+
+        it 'creates an after callback with custom scope' do
+          callback = Callback.new(:after, :each_ruby) { 'test' }
+          expect(callback.type).to eq :after
+          expect(callback.scope).to eq :each_ruby
+        end
+
+        it 'raises error for invalid scope' do
+          expect { Callback.new(:before, :invalid) { 'test' } }.to raise_error(ArgumentError)
+        end
+      end
+
+      describe '#call' do
+        it 'executes the block without arguments' do
+          result = nil
+          callback = Callback.new(:before) { result = 'executed' }
+          callback.call
+          expect(result).to eq 'executed'
+        end
+
+        it 'executes the block with environment argument' do
+          result = nil
+          callback = Callback.new(:before, :each_ruby) { |env| result = env[:ruby_version] }
+          callback.call(ruby_version: '3.0.0')
+          expect(result).to eq '3.0.0'
+        end
+      end
+
+      describe '#before?' do
+        it 'returns true for before callbacks' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback).to be_before
+        end
+
+        it 'returns false for after callbacks' do
+          callback = Callback.new(:after) { 'test' }
+          expect(callback).not_to be_before
+        end
+      end
+
+      describe '#after?' do
+        it 'returns true for after callbacks' do
+          callback = Callback.new(:after) { 'test' }
+          expect(callback).to be_after
+        end
+
+        it 'returns false for before callbacks' do
+          callback = Callback.new(:before) { 'test' }
+          expect(callback).not_to be_after
+        end
+      end
+
+      describe '#all?' do
+        it 'returns true for all scope' do
+          callback = Callback.new(:before, :all) { 'test' }
+          expect(callback).to be_all
+        end
+
+        it 'returns false for each_ruby scope' do
+          callback = Callback.new(:before, :each_ruby) { 'test' }
+          expect(callback).not_to be_all
+        end
+      end
+
+      describe '#each_ruby?' do
+        it 'returns true for each_ruby scope' do
+          callback = Callback.new(:before, :each_ruby) { 'test' }
+          expect(callback).to be_each_ruby
+        end
+
+        it 'returns false for all scope' do
+          callback = Callback.new(:before, :all) { 'test' }
+          expect(callback).not_to be_each_ruby
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/changed_file_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module InfinityTest
+  describe ChangedFile do
+    let(:match_data) { /(.)(.)(\d+)(\d)/.match("THX1138.") }
+    let(:changed_file) { ChangedFile.new(match_data) }
+
+    describe '#name' do
+      subject { changed_file.name }
+
+      it { should eq 'HX1138' }
+    end
+
+    describe '#path' do
+      subject { changed_file.path }
+
+      it { should eq 'H' }
+    end
+
+    describe '#match_data' do
+      subject { changed_file.match_data }
+
+      it { should be match_data }
+    end
+  end
+end

data/spec/infinity_test/core/command_builder_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe CommandBuilder do
+      describe "#add" do
+        it "adds the argument in the command" do
+          expect(subject.ruby.option(:S).add(:rspec).add(:spec)).to eq 'ruby -S rspec spec'
+        end
+      end
+
+      describe "#option" do
+        it "puts options with one dash and allows adding more keywords" do
+          expect(subject.bundle.exec.ruby.option(:S).rspec).to eq 'bundle exec ruby -S rspec'
+        end
+      end
+
+      describe "#opt" do
+        it "puts double dash options and allows adding keywords" do
+          expect(subject.ruby.opt(:copyright)).to eq 'ruby --copyright'
+        end
+      end
+
+      describe '#method_missing' do
+        it "puts space after every keyword" do
+          expect(subject.bundle.exec.ruby.some_file).to eq 'bundle exec ruby some_file'
+        end
+      end
+
+      describe "#respond_to?" do
+        it "responds to anything because missing methods will build the command" do
+          expect(subject.respond_to?(:foo)).to be true
+          expect(subject.respond_to?(:bar)).to be true
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/configuration_merge_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe ConfigurationMerge do
+      let(:base) do
+        OpenStruct.new(
+          :bundler => true,
+          :verbose => true,
+          :strategy => :auto_discover,
+          :observer => :watchr,
+          :rubies => [],
+          :specific_options => '',
+          :framework => :auto_discover,
+          :test_framework => :auto_discover,
+          :infinity_and_beyond => true
+        )
+      end
+
+      let(:options) { Options.new([]) }
+      subject { ConfigurationMerge.new(base, options) }
+
+      describe "#merge!" do
+        it "keeps the strategy when options strategy is blank" do
+          subject.merge!
+          expect(base.strategy).to be :auto_discover
+        end
+
+        it "merges the strategies" do
+          expect(options).to receive(:strategy).twice.and_return(:rbenv)
+          subject.merge!
+          expect(base.strategy).to be :rbenv
+        end
+
+        it "keeps the rubies when options rubies is nil" do
+          base.rubies = %w(jruby ree)
+          expect(options).to receive(:rubies).and_return(nil)
+          subject.merge!
+          expect(base.rubies).to eq %w(jruby ree)
+        end
+
+        it "overwrites the rubies when options rubies is empty" do
+          base.rubies = %w(jruby ree)
+          expect(options).to receive(:rubies).twice.and_return([])
+          subject.merge!
+          expect(base.rubies).to be_blank
+        end
+
+        it "merges the rubies" do
+          expect(options).to receive(:rubies).twice.and_return(%w(ree jruby))
+          subject.merge!
+          expect(base.rubies).to eql %w(ree jruby)
+        end
+
+        it "keeps the test framework when options test framework is blank" do
+          subject.merge!
+          expect(base.test_framework).to be :auto_discover
+        end
+
+        it "merges the test library" do
+          expect(options).to receive(:test_framework).twice.and_return(:rspec)
+          subject.merge!
+          expect(base.test_framework).to be :rspec
+        end
+
+        it "keeps the framework when options framework is blank" do
+          subject.merge!
+          expect(base.framework).to be :auto_discover
+        end
+
+        it "merges the framework" do
+          expect(options).to receive(:framework).twice.and_return(:rails)
+          subject.merge!
+          expect(base.framework).to be :rails
+        end
+
+        it "keeps the specific option when options specific is blank" do
+          subject.merge!
+          expect(base.specific_options).to eql ''
+        end
+
+        it "merges the specific options" do
+          expect(options).to receive(:specific_options).twice.and_return('-J -Ilib -Itest')
+          subject.merge!
+          expect(base.specific_options).to eql '-J -Ilib -Itest'
+        end
+
+        it "merges with the infinity test and beyond" do
+          expect(options).to receive(:infinity_and_beyond).twice.and_return(false)
+          subject.merge!
+          expect(base.infinity_and_beyond).to be false
+        end
+
+        it "keeps the base default if option infinity test and beyond is nil" do
+          expect(options).to receive(:infinity_and_beyond).and_return(nil)
+          subject.merge!
+          expect(base.infinity_and_beyond).to be true
+        end
+
+        it "keeps the verbose mode when verbose mode is blank" do
+          subject.merge!
+          expect(base.verbose).to be true
+        end
+
+        it "merges the verbose mode" do
+          expect(options).to receive(:verbose).twice.and_return(false)
+          subject.merge!
+          expect(base.verbose).to be false
+        end
+
+        it "keeps the bundler default when bundler is blank" do
+          subject.merge!
+          expect(base.bundler).to be true
+        end
+
+        it "merges the bundler mode" do
+          expect(options).to receive(:bundler).twice.and_return(false)
+          subject.merge!
+          expect(base.bundler).to be false
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/continuous_test_server_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe ContinuousTestServer do
+      let(:base) { Core::Base }
+      let(:continuous_test_server) { ContinuousTestServer.new(base) }
+
+      describe '#start!' do
+        it 'runs strategy and starts observer' do
+          expect(continuous_test_server).to receive(:run_strategy)
+          expect(continuous_test_server).to receive(:start_observer)
+          continuous_test_server.start
+        end
+      end
+
+      describe '#start_observer' do
+        context 'when base configuration as infinity and beyond' do
+          before do
+            expect(base).to receive(:infinity_and_beyond).and_return(true)
+            allow(base).to receive(:framework).and_return(:rails)
+            allow(base).to receive(:observer).and_return(:listen)
+          end
+
+          it 'adds framework heuristics and starts the observer' do
+            expect(continuous_test_server.framework).to receive(:heuristics!)
+            expect(continuous_test_server.observer).to receive(:start!)
+            continuous_test_server.start_observer
+          end
+        end
+
+        context 'when base configuration is not infinity and beyond' do
+          before do
+            expect(base).to receive(:infinity_and_beyond).and_return(false)
+            allow(base).to receive(:framework).and_return(:rails)
+          end
+
+          it 'does not start the observer' do
+            expect(continuous_test_server.framework).to_not receive(:heuristics!)
+            expect(continuous_test_server.observer).to_not receive(:start!)
+            continuous_test_server.start_observer
+          end
+        end
+      end
+
+      describe '#notify' do
+        let(:continuous_test_server) { ContinuousTestServer.new(base) }
+        let(:test_message) { '200 examples, 0 failures, 0 pending' }
+
+        context 'when have notification library' do
+          let(:test_framework) { double }
+          let(:base) { double(notifications: :auto_discover) }
+
+          before do
+            expect(continuous_test_server).to receive(:test_framework).exactly(:twice).and_return(test_framework)
+            expect(test_framework).to receive(:test_message=).with(test_message)
+          end
+
+          it 'instantiates a notifier passing the strategy result and the continuous server' do
+            expect(Core::Notifier).to receive(:new).and_return(double(notify: true))
+            continuous_test_server.notify(test_message)
+          end
+        end
+
+        context 'when do not have notification library' do
+          let(:base) { double(notifications: nil) }
+
+          it 'does not instantiate a notifier' do
+            expect(Core::Notifier).to_not receive(:new)
+            continuous_test_server.notify(test_message)
+          end
+        end
+      end
+
+      describe '#rerun_strategy' do
+        let(:test_framework) { double }
+
+        before do
+          expect(continuous_test_server).to receive(:test_framework).twice.and_return(test_framework)
+        end
+
+        it 'runs strategy again and ensures the test files is nil after' do
+          expect(test_framework).to receive(:test_files=).twice
+          expect(continuous_test_server).to receive(:run_strategy)
+          continuous_test_server.rerun_strategy('base_test.py')
+        end
+      end
+
+      describe '#strategy' do
+        subject { continuous_test_server.strategy }
+        before { expect(base).to receive(:strategy).and_return(:ruby_default) }
+
+        it { should be_instance_of InfinityTest::Strategy::RubyDefault }
+      end
+
+      describe '#test_framework' do
+        subject { continuous_test_server.test_framework }
+        before { expect(base).to receive(:test_framework).and_return(:rspec) }
+
+        it { should be_instance_of InfinityTest::TestFramework::Rspec }
+      end
+
+      describe '#binary' do
+        subject { continuous_test_server }
+
+        it { should respond_to :binary }
+      end
+
+      describe '#test_files' do
+        subject { continuous_test_server }
+
+        it { should respond_to :test_files }
+      end
+    end
+  end
+end

data/spec/infinity_test/core/load_configuration_spec.rb

@@ -0,0 +1,43 @@
+require "spec_helper"
+
+module InfinityTest
+  describe LoadConfiguration do
+    describe "#load!" do
+      it "loads global file and project file" do
+        expect(subject).to receive(:load_global_file!).and_return(true)
+        expect(subject).to receive(:load_project_file!).and_return(true)
+        subject.load!
+      end
+    end
+
+    describe "#load_global_file!" do
+      it "loads the global file" do
+        subject.global_file = 'foo'
+        expect(subject).to receive(:load_file).with('foo').and_return(true)
+        subject.load_global_file!
+      end
+    end
+
+    describe "#load_project_file!" do
+      it "loads the project file" do
+        subject.project_file = 'bar'
+        expect(subject).to receive(:load_file).with('bar').and_return(true)
+        subject.load_project_file!
+      end
+    end
+
+    describe "#load_file" do
+      it "loads if file exists" do
+        expect(File).to receive(:exist?).with('bar').and_return(true)
+        expect(subject).to receive(:load).with('bar').and_return(true)
+        expect(subject.load_file('bar')).to be true
+      end
+
+      it "does not load if file does not exist" do
+        expect(File).to receive(:exist?).with('baz').and_return(false)
+        expect(subject).to_not receive(:load)
+        subject.load_file('baz')
+      end
+    end
+  end
+end