infinity_test 1.0.3 → 2.0.0.rc2

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

data/spec/infinity_test/core/notifier_spec.rb

@@ -0,0 +1,151 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Core
+    describe Notifier do
+      let(:test_framework) { double }
+
+      subject(:notifier) { Notifier.new(test_framework: test_framework, library: :auto_discover) }
+
+      describe '#image' do
+        before do
+          expect(Core::Base).to receive(:mode).and_return(:simpson)
+        end
+
+        context 'when success tests' do
+          before do
+            expect(test_framework).to receive(:success?).and_return(true)
+          end
+
+          it 'returns the success image' do
+            expect(notifier.image).to include 'success'
+          end
+        end
+
+        context 'when pending tests' do
+          before do
+            expect(test_framework).to receive(:success?).and_return(false)
+            expect(test_framework).to receive(:failure?).and_return(false)
+          end
+
+          it 'returns the pending image' do
+            expect(notifier.image).to include 'pending'
+          end
+        end
+
+        context 'when failing tests' do
+          before do
+            expect(test_framework).to receive(:success?).and_return(false)
+            expect(test_framework).to receive(:failure?).and_return(true)
+          end
+
+          it 'returns the failure image' do
+            expect(notifier.image).to include 'failure'
+          end
+        end
+      end
+
+      describe '#library' do
+        it 'returns the primitive value' do
+          expect(notifier.library).to be :auto_discover
+        end
+      end
+
+      describe '#test_message' do
+        it 'respond to' do
+          expect(notifier).to respond_to(:test_message)
+        end
+      end
+
+      describe '#images_dir' do
+        context 'when is default infinity test dir' do
+          before do
+            expect(Core::Base).to receive(:mode).and_return(:simpson)
+          end
+
+          it 'returns the dir with the base mode' do
+            expect(notifier.images_dir).to include '/images/simpson'
+          end
+        end
+
+        context 'when is pre defined images dir' do
+          before do
+            expect(Core::Base).to receive(:mode).and_return('/my_images_dir')
+          end
+
+          it 'returns the user dir expanded path' do
+            expect(notifier.images_dir).to eq '/my_images_dir'
+          end
+        end
+      end
+
+      describe '#success_image' do
+        context 'when core base image is blank' do
+          it 'find a image inside mode dir' do
+            expect(notifier).to receive(:find_image).with(:success)
+            notifier.success_image
+          end
+        end
+
+        context 'when core base has a image' do
+          it 'returns core base image' do
+            expect(Core::Base).to receive(:success_image).and_return('some_image.png')
+            expect(notifier.success_image).to eq 'some_image.png'
+          end
+        end
+      end
+
+      describe '#failure_image' do
+        context 'when core base image is blank' do
+          it 'find a image inside mode dir' do
+            expect(notifier).to receive(:find_image).with(:failure)
+            notifier.failure_image
+          end
+        end
+
+        context 'when core base has a image' do
+          it 'returns core base image' do
+            expect(Core::Base).to receive(:failure_image).and_return('some_image.png')
+            expect(notifier.failure_image).to eq 'some_image.png'
+          end
+        end
+      end
+
+      describe '#pending_image' do
+        context 'when core base image is blank' do
+          it 'find a image inside mode dir' do
+            expect(notifier).to receive(:find_image).with(:pending)
+            notifier.pending_image
+          end
+        end
+
+        context 'when core base has a image' do
+          it 'returns core base image' do
+            expect(Core::Base).to receive(:pending_image).and_return('some_image.png')
+            expect(notifier.pending_image).to eq 'some_image.png'
+          end
+        end
+      end
+
+      describe '#notify' do
+        let(:notification_builder) { double }
+
+        before do
+          expect(Core::Base).to receive(:mode).and_return(:simpson)
+          expect(test_framework).to receive(:success?).and_return(true)
+          expect(test_framework).to receive(:test_message).and_return('5 examples, 0 failures')
+        end
+
+        it 'sends a notification with title, message and image' do
+          expect(notifier).to receive(:auto_discover).and_return(notification_builder)
+          expect(notification_builder).to receive(:title).with(RUBY_VERSION).and_return(notification_builder)
+          expect(notification_builder).to receive(:message).with('5 examples, 0 failures').and_return(notification_builder)
+          expect(notification_builder).to receive(:image).and_return(notification_builder)
+          expect(notification_builder).to receive(:notify)
+
+          notifier.notify
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/core/options_spec.rb

@@ -0,0 +1,168 @@
+require "spec_helper"
+
+module InfinityTest
+  describe Options do
+    describe "#parse!" do
+      describe "#strategy" do
+        it "parses the --ruby options with rvm" do
+          expect(parse('--ruby', 'rvm').strategy).to be :rvm
+        end
+
+        it "parses the --ruby options with rbenv" do
+          expect(parse('--ruby', 'rbenv').strategy).to be :rbenv
+        end
+      end
+
+      describe "#rubies" do
+        it "passes the ruby versions" do
+          expect(parse('--rubies=ree,jruby').rubies).to eql %w(ree jruby)
+        end
+
+        it "has empty rubies when pass rubies= without versions" do
+          expect(parse('--rubies=').rubies).to eql []
+        end
+
+        it "is nil when rubies option is not passed" do
+          expect(parse.rubies).to be_nil
+        end
+      end
+
+      describe "#infinity_and_beyond" do
+        it "returns false when setting --no-infinity-and-beyond" do
+          expect(parse('--no-infinity-and-beyond').infinity_and_beyond).to equal false
+          expect(parse('-n').infinity_and_beyond).to equal false
+        end
+
+        it "returns nil when not setting the --no-infinity-and-beyond" do
+          expect(parse.infinity_and_beyond).to be_nil
+        end
+      end
+
+      describe "#specific_options" do
+        it "parses the options" do
+          expect(parse('--options=-J-Ilib-Itest').specific_options).to eql '-J -Ilib -Itest'
+        end
+      end
+
+      describe "#test_framework" do
+        it "parses the test framework as rspec" do
+          expect(parse('--test', 'rspec').test_framework).to be :rspec
+        end
+
+        it "parses the test framework as test_unit" do
+          expect(parse('--test', 'test_unit').test_framework).to be :test_unit
+        end
+
+        it "parses the test framework as other" do
+          expect(parse('--test', 'other').test_framework).to be :other
+        end
+      end
+
+      describe "#framework" do
+        it "parses the app framework as rails" do
+          expect(parse('--framework', 'rails').framework).to be :rails
+        end
+
+        it "parses the app framework as rubygems" do
+          expect(parse('--framework', 'rubygems').framework).to be :rubygems
+        end
+
+        it "parses the app framework as other" do
+          expect(parse('--framework', 'other').framework).to be :other
+        end
+      end
+
+      describe "#verbose?" do
+        it "returns nil when nothing is passed" do
+          expect(parse.verbose?).to be_nil
+        end
+
+        it "is not verbose when passing the option --no-verbose" do
+          expect(parse('--no-verbose')).not_to be_verbose
+        end
+      end
+
+      describe "#bundler?" do
+        it "does not use bundler when passing this option" do
+          expect(parse('--no-bundler')).not_to be_bundler
+        end
+
+        it "returns nil when nothing is passed" do
+          expect(parse.bundler?).to be_nil
+        end
+      end
+
+      describe "#notifications" do
+        it "parses the notifications library as auto_discover" do
+          expect(parse('--notifications', 'auto_discover').notifications).to be :auto_discover
+        end
+
+        it "parses the notifications library as osascript" do
+          expect(parse('--notifications', 'osascript').notifications).to be :osascript
+        end
+
+        it "parses the notifications library as terminal_notifier" do
+          expect(parse('--notifications', 'terminal_notifier').notifications).to be :terminal_notifier
+        end
+
+        it "returns nil when nothing is passed" do
+          expect(parse.notifications).to be_nil
+        end
+      end
+
+      describe "#mode" do
+        it "parses the image mode as simpson" do
+          expect(parse('--mode', 'simpson').mode).to be :simpson
+        end
+
+        it "parses the image mode as faces" do
+          expect(parse('--mode', 'faces').mode).to be :faces
+        end
+
+        it "parses the image mode as rails" do
+          expect(parse('--mode', 'rails').mode).to be :rails
+        end
+
+        it "returns nil when nothing is passed" do
+          expect(parse.mode).to be_nil
+        end
+      end
+
+      describe "#just_watch" do
+        it "returns true when setting --just-watch" do
+          expect(parse('--just-watch').just_watch).to eq true
+        end
+
+        it "returns true when setting -j" do
+          expect(parse('-j').just_watch).to eq true
+        end
+
+        it "returns nil when nothing is passed" do
+          expect(parse.just_watch).to be_nil
+        end
+      end
+
+      describe "#focus" do
+        it "parses --focus with file path" do
+          expect(parse('--focus', 'spec/models/user_spec.rb').focus).to eq 'spec/models/user_spec.rb'
+        end
+
+        it "parses -f with file path" do
+          expect(parse('-f', 'spec/models/user_spec.rb').focus).to eq 'spec/models/user_spec.rb'
+        end
+
+        it "parses --focus failures as symbol" do
+          expect(parse('--focus', 'failures').focus).to eq :failures
+        end
+
+        it "returns nil when nothing is passed" do
+          expect(parse.focus).to be_nil
+        end
+      end
+    end
+
+    def parse(*args)
+      InfinityTest::Options.new(args.flatten).parse!
+    end
+  end
+end

data/spec/infinity_test/core/runner_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+module InfinityTest
+  describe Runner do
+    let(:runner) { Runner.new('--ruby', 'rvm') }
+
+    describe '#start' do
+      it 'load configuration, merge with command line, find user libraries and start continuous server' do
+        expect_any_instance_of(Core::LoadConfiguration).to receive(:load!)
+        expect(Core::Base).to receive(:merge!).with(runner.options)
+        expect_any_instance_of(Core::AutoDiscover).to receive(:discover_libraries)
+        expect_any_instance_of(ContinuousTestServer).to receive(:start)
+        runner.start
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/base_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Base do
+      subject(:base) { Base.new(continuous_test_server) }
+      let(:continuous_test_server) { double(extension: :rb) }
+
+      describe '#run_all' do
+        it 'call run strategy to continuous test server' do
+          expect(continuous_test_server).to receive(:run_strategy)
+          base.run_all
+        end
+      end
+
+      describe '#run_test' do
+        let(:test_framework) { double(test_dir: 'test') }
+
+        before do
+          expect(base).to receive(:test_framework).and_return(test_framework)
+        end
+
+        context 'find a file' do
+          it 'call run strategy to continuous test server' do
+            expect(base.hike).to receive(:find).with('framework/base_test.rb').and_return('framework/base_test.rb')
+            expect(continuous_test_server).to receive(:rerun_strategy).with('framework/base_test.rb')
+            base.run_test(double(path: 'framework/base'))
+          end
+
+          it 'use the extension name from core base' do
+            expect(base).to receive(:extension).and_return('py')
+            expect(base.hike).to receive(:find).with('framework/base_test.py').and_return('framework/base_test.py')
+            expect(continuous_test_server).to receive(:rerun_strategy).with('framework/base_test.py')
+            base.run_test(double(path: 'framework/base'))
+          end
+        end
+
+        context 'when do not find any files' do
+          it 'do not call rerun strategy' do
+            expect(base.hike).to receive(:find).with('test_framework/rspec_test.rb').and_return(nil)
+            expect(continuous_test_server).to_not receive(:rerun_strategy)
+            base.run_test(double(path: 'test_framework/rspec'))
+          end
+        end
+      end
+
+      describe '#run_file' do
+        it 'rerun strategy passing the changed file path' do
+          expect(continuous_test_server).to receive(:rerun_strategy).with('base_spec.rb')
+          base.run_file(double(name: 'base_spec.rb', path: 'base_spec'))
+        end
+      end
+    end
+  end
+end