infinity_test 1.0.2 → 2.0.0.rc1

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

data/spec/infinity_test/framework/padrino_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Padrino do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework') }
+      let(:continuous_test_server) { double('ContinuousTestServer', observer: observer, test_framework: test_framework) }
+      subject { Padrino.new(continuous_test_server) }
+
+      describe "#heuristics" do
+        it "adds heuristics" do
+          # 6 watch_dir calls: models, controllers, helpers, mailers, lib, test_dir
+          expect(observer).to receive(:watch_dir).exactly(6)
+          # 1 watch call for test_helper_file
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+          expect(test_framework).to receive(:test_dir)
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if config/apps.rb exists" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/apps.rb')).and_return(true)
+          expect(Padrino).to be_run
+        end
+
+        it "returns false if config/apps.rb does not exist" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/apps.rb')).and_return(false)
+          expect(Padrino).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/rails_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module InfinityTest
+  module Framework
+    describe Rails do
+      let(:observer) { double('Observer') }
+      let(:test_framework) { double('TestFramework') }
+      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
+          expect(observer).to receive(:watch)
+          expect(test_framework).to receive(:test_helper_file)
+          expect(test_framework).to receive(:test_dir)
+          expect { subject.heuristics }.to_not raise_exception
+        end
+      end
+
+      describe ".run?" do
+        it "returns true if config/environment.rb exists" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/environment.rb')).and_return(true)
+          expect(Rails).to be_run
+        end
+
+        it "returns false if config/environment.rb does not exist" do
+          expect(File).to receive(:exist?).with(File.expand_path('./config/environment.rb')).and_return(false)
+          expect(Rails).not_to be_run
+        end
+      end
+    end
+  end
+end

data/spec/infinity_test/framework/rubygems_spec.rb

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

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