guard-rspec 4.0.4 → 4.1.0

data/spec/lib/guard/rspec/inspectors/keeping_inspector_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+require 'lib/guard/rspec/inspectors/shared_examples'
+
+klass = Guard::RSpec::Inspectors::KeepingInspector
+
+describe klass do
+  include_examples 'inspector', klass
+
+  # Use real paths because BaseInspector#_clean will be used to clean them
+  let(:other_paths) { [
+    'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb',
+    'spec/lib/guard/rspec/runner_spec.rb'
+  ] }
+  let(:other_failed_locations) { [
+    './spec/lib/guard/rspec/runner_spec.rb:12',
+    './spec/lib/guard/rspec/runner_spec.rb:100',
+    './spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb:12'
+  ] }
+
+  it 'remembers failed paths and returns them along with new paths' do
+    expect(inspector.paths(paths)).to eq(paths)
+    inspector.failed(failed_locations)
+
+    # Line numbers in failed_locations needs to be omitted because of
+    # https://github.com/rspec/rspec-core/issues/952
+    expect(inspector.paths(other_paths)).to match_array([
+      'spec/lib/guard/rspec/deprecator_spec.rb',
+      'spec/lib/guard/rspec/runner_spec.rb',
+      'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb'
+    ])
+    inspector.failed(other_failed_locations)
+
+    # Now it returns other failed locations
+    expect(inspector.paths(%w[spec/lib/guard/rspec/inspectors/base_inspector_spec.rb])).to match_array([
+      'spec/lib/guard/rspec/runner_spec.rb',
+      'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb',
+      'spec/lib/guard/rspec/inspectors/base_inspector_spec.rb'
+    ])
+    inspector.failed(other_failed_locations)
+
+    expect(inspector.paths(%w[spec/lib/guard/rspec/runner_spec.rb])).to match_array([
+      'spec/lib/guard/rspec/runner_spec.rb',
+      'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb'
+    ])
+    inspector.failed([])
+
+    # Now there is no failed locations
+    expect(inspector.paths(paths)).to match_array(paths)
+  end
+
+  describe '#reload' do
+    it 'force to forget about failed locations' do
+      expect(inspector.paths(paths)).to eq(paths)
+      inspector.failed(failed_locations)
+
+      inspector.reload
+      expect(inspector.paths(other_paths)).to match_array(other_paths)
+    end
+  end
+end
+
+#
+#  FIXME uncomment when RSpec #952 will be resolved
+#
+#  This is correct spec for KeepingInspector class,
+#  bit it doesn't work because of bug with RSpec
+#  https://github.com/rspec/rspec-core/issues/952
+#
+#describe klass do
+#  include_examples 'inspector', klass
+#
+#  # Use real paths because BaseInspector#_clean will be used to clean them
+#  let(:other_paths) { [
+#    'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb',
+#    'spec/lib/guard/rspec/runner_spec.rb'
+#  ] }
+#  let(:other_failed_locations) { [
+#    './spec/lib/guard/rspec/runner_spec.rb:12',
+#    './spec/lib/guard/rspec/runner_spec.rb:100',
+#    './spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb:12'
+#  ] }
+#
+#  it 'remembers failed paths and returns them along with new paths' do
+#    expect(inspector.paths(paths)).to eq(paths)
+#    inspector.failed(failed_locations)
+#
+#    # other_paths and failed_locations contain the same spec (runner_spec.rb)
+#    # so #paths should return that spec only once (omit location)
+#    expect(inspector.paths(other_paths)).to match_array(
+#      other_paths +
+#      %w[./spec/lib/guard/rspec/deprecator_spec.rb:55]
+#    )
+#    inspector.failed(other_failed_locations)
+#
+#    # Now it returns other failed locations
+#    expect(inspector.paths(%w[spec/lib/guard/rspec/deprecator_spec.rb])).to match_array(
+#      other_failed_locations +
+#      %w[spec/lib/guard/rspec/deprecator_spec.rb]
+#    )
+#    inspector.failed(other_failed_locations)
+#
+#    # It returns runner_spec.rb without locations in that spec
+#    expect(inspector.paths(%w[spec/lib/guard/rspec/runner_spec.rb])).to match_array([
+#      './spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb:12',
+#      'spec/lib/guard/rspec/runner_spec.rb'
+#    ])
+#    inspector.failed([])
+#
+#    # Now there is no failed locations
+#    expect(inspector.paths(paths)).to match_array(paths)
+#  end
+#
+#  describe '#reload' do
+#    it 'force to forget about failed locations' do
+#      expect(inspector.paths(paths)).to eq(paths)
+#      inspector.failed(failed_locations)
+#
+#      inspector.reload
+#      expect(inspector.paths(other_paths)).to match_array(other_paths)
+#    end
+#  end
+#end

data/spec/lib/guard/rspec/inspectors/shared_examples.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+shared_examples 'inspector' do |klass|
+  let(:spec_paths) { %w[spec myspec] }
+  let(:options) { { custom: 'value', spec_paths: spec_paths } }
+  let(:inspector) { klass.new(options) }
+
+  # Use real paths because BaseInspector#_clean will be used to clean them
+  let(:paths) { [
+    'spec/lib/guard/rspec/inspectors/base_inspector_spec.rb',
+    'spec/lib/guard/rspec/runner_spec.rb',
+    'spec/lib/guard/rspec/deprecator_spec.rb'
+  ] }
+  let(:failed_locations) { [
+    './spec/lib/guard/rspec/runner_spec.rb:12',
+    './spec/lib/guard/rspec/deprecator_spec.rb:55'
+  ] }
+
+  describe '.initialize' do
+    it 'sets options and spec_paths' do
+      expect(inspector.options).to include(:custom, :spec_paths)
+      expect(inspector.options[:custom]).to eq('value')
+      expect(inspector.spec_paths).to eq(spec_paths)
+    end
+  end
+
+  describe '#paths' do
+    it 'returns paths when called first time' do
+      expect(inspector.paths(paths)).to match_array(paths)
+    end
+
+    it 'does not return non-spec paths' do
+      paths = %w[not_a_spec_path.rb spec/not_exist_spec.rb]
+      expect(inspector.paths(paths)).to eq([])
+    end
+
+    it 'uniq and compact paths' do
+      expect(inspector.paths(paths + paths + [nil, nil, nil])).to match_array(paths)
+    end
+
+    # NOTE: I'm not sure that it is totally correct behaviour
+    it 'return spec_paths and directories too' do
+      paths = %w[myspec lib/guard not_exist_dir]
+      expect(inspector.paths(paths)).to match_array(paths - ['not_exist_dir'])
+    end
+  end
+
+  describe '#failed' do
+    it 'is callable' do
+      expect { inspector.failed(failed_locations) }.not_to raise_error
+    end
+  end
+
+  describe '#reload' do
+    it 'is callable' do
+      expect { inspector.reload }.not_to raise_error
+    end
+  end
+end

data/spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'lib/guard/rspec/inspectors/shared_examples'
+
+klass = Guard::RSpec::Inspectors::SimpleInspector
+
+describe klass do
+  include_examples 'inspector', klass
+
+  # Use real paths because BaseInspector#_clean will be used to clean them
+  let(:other_paths) { [
+    'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb',
+    'spec/lib/guard/rspec/runner_spec.rb'
+  ] }
+
+  it 'returns paths and do not bothers about failed locations' do
+    2.times do
+      expect(inspector.paths(paths)).to eq(paths)
+      inspector.failed(failed_locations)
+      expect(inspector.paths(other_paths)).to eq(other_paths)
+      inspector.failed([])
+    end
+  end
+end

data/spec/lib/guard/rspec/notifier_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Guard::RSpec::Notifier do
+  let(:options) { { notification: true } }
+  let(:notifier) { Guard::RSpec::Notifier.new(options) }
+
+  def expect_notification(message, image, priority)
+    expect(Guard::Notifier).to receive(:notify).with(message, { title: 'RSpec results', image: image, priority: priority })
+  end
+
+  describe '#notify_failure' do
+    it 'notifies about failure' do
+      expect_notification('Failed', :failed, 2)
+      notifier.notify_failure
+    end
+  end
+
+  describe '#notify' do
+    it 'notifies about success' do
+      expect_notification('This is summary', :success, -2)
+      notifier.notify('This is summary')
+    end
+
+    context 'with pendings' do
+      let(:summary) { '5 examples, 0 failures (1 pending) in 4.0000 seconds' }
+
+      it 'notifies about pendings' do
+        expect_notification(summary, :pending, -1)
+        notifier.notify(summary)
+      end
+    end
+
+    context 'with failures' do
+      let(:summary) { '5 examples, 1 failures in 4.0000 seconds' }
+
+      it 'notifies about failures' do
+        expect_notification(summary, :failed, 2)
+        notifier.notify(summary)
+      end
+
+      context 'even if there is pendings' do
+        let(:summary) { '5 examples, 1 failures (1 pending) in 4.0000 seconds' }
+
+        it 'still notifies about failures' do
+          expect_notification(summary, :failed, 2)
+          notifier.notify(summary)
+        end
+      end
+    end
+  end
+
+  context 'with notifications turned off' do
+    let(:options) { { notification: false } }
+
+    describe '#notify_failure' do
+      it 'keeps quiet' do
+        expect(Guard::Notifier).not_to receive(:notify)
+        notifier.notify_failure
+      end
+    end
+
+    describe '#notify' do
+      it 'keeps quiet' do
+        expect(Guard::Notifier).not_to receive(:notify)
+        notifier.notify('Summary')
+      end
+    end
+  end
+end

data/spec/lib/guard/rspec/runner_spec.rb

@@ -2,135 +2,144 @@ require 'spec_helper'
 require 'launchy'
 
 describe Guard::RSpec::Runner do
-  let(:default_options) { {
-    all_after_pass:  false,
-    notification: true,
-    run_all: { message: 'Running all specs' },
-    launchy: nil,
-  } }
   let(:options) { {} }
   let(:runner) { Guard::RSpec::Runner.new(options) }
-  let(:inspector) { double(Guard::RSpec::Inspector) }
+  let(:inspector) { double(Guard::RSpec::Inspectors::SimpleInspector) }
+  let(:notifier) { double(Guard::RSpec::Notifier) }
+  let(:formatter_tmp_file) { Guard::RSpec::Formatter::TEMPORARY_FILE_PATH }
   before {
     Guard::UI.stub(:info)
     Kernel.stub(:system) { true }
-    Guard::RSpec::Inspector.stub(:new) { inspector }
+    Guard::RSpec::Inspectors::Factory.stub(:create) { inspector }
+    Guard::RSpec::Notifier.stub(:new) { notifier }
     Guard::RSpec::Command.stub(:new) { 'rspec' }
+    notifier.stub(:notify)
+    notifier.stub(:notify_failure)
   }
 
   describe '.initialize' do
-    it 'instanciates inspector with options' do
-      expect(Guard::RSpec::Inspector).to receive(:new).with(default_options.merge(foo: :bar))
-      Guard::RSpec::Runner.new(foo: :bar)
+    context 'with custom options' do
+      let(:options) { { foo: :bar } }
+
+      it 'instanciates inspector via Inspectors::Factory with custom options' do
+        expect(Guard::RSpec::Inspectors::Factory).to receive(:create).with(foo: :bar)
+        runner
+      end
+
+      it 'instanciates notifier with custom options' do
+        expect(Guard::RSpec::Notifier).to receive(:new).with(foo: :bar)
+        runner
+      end
     end
   end
 
-  describe "#reloads" do
-    it "clears inspector failed_paths" do
-      expect(inspector).to receive(:clear_paths)
+  describe '#reload' do
+    it 'calls inspector\'s #reload' do
+      expect(inspector).to receive(:reload)
       runner.reload
     end
   end
 
-  describe "#run_all" do
-    before {
-      inspector.stub(:paths) { %w[spec1 spec2] }
-      inspector.stub(:clear_paths) { true }
-    }
+  describe '#run_all' do
+    let(:options) { {
+      spec_paths: %w[spec1 spec2],
+      run_all: { message: 'Custom message' }
+    } }
 
-    it "prints default message" do
-      expect(Guard::UI).to receive(:info).with(default_options[:run_all][:message], reset: true)
+    it 'builds commands with spec paths' do
+      expect(Guard::RSpec::Command).to receive(:new).with(%w[spec1 spec2], kind_of(Hash))
       runner.run_all
     end
 
-    context "with custom message" do
-      let(:options) { { run_all: { message: 'Custom message' } } }
-
-      it "prints custom message" do
-        expect(Guard::UI).to receive(:info).with('Custom message', reset: true)
-        runner.run_all
-      end
+    it 'prints message' do
+      expect(Guard::UI).to receive(:info).with('Custom message', reset: true)
+      runner.run_all
     end
 
-    context "with custom cmd" do
-      let(:options) { { run_all: { cmd: 'rspec -t ~slow' } } }
+    context 'with custom cmd' do
+      before {
+        options[:run_all][:cmd] = 'rspec -t ~slow'
+      }
 
-      it "builds command with custom options" do
+      it 'builds command with custom cmd' do
         expect(Guard::RSpec::Command).to receive(:new).with(kind_of(Array), hash_including(cmd: 'rspec -t ~slow'))
         runner.run_all
       end
     end
-
-    it "builds commands with all spec paths" do
-      expect(Guard::RSpec::Command).to receive(:new).with(%w[spec1 spec2], kind_of(Hash))
-      runner.run_all
-    end
-
-    it "clears inspector paths if run is success" do
-      expect(inspector).to receive(:clear_paths)
-      runner.run_all
-    end
   end
 
-  describe "#run" do
+  describe '#run' do
     let(:paths) { %w[spec_path1 spec_path2] }
     before {
-      inspector.stub(:failed_paths) { [] }
+      File.stub(:readlines).with(formatter_tmp_file) { %W{Summary\n} }
       inspector.stub(:paths) { paths }
       inspector.stub(:clear_paths) { true }
+      inspector.stub(:failed)
     }
 
-    it "prints running message" do
+    it 'prints running message' do
       expect(Guard::UI).to receive(:info).with('Running: spec_path1 spec_path2', reset: true)
       runner.run(paths)
     end
 
-    it "returns if no paths are given" do
+    it 'returns if no paths are given' do
       inspector.stub(:paths) { [] }
       expect(Guard::UI).to_not receive(:info)
       runner.run([])
     end
 
-    it "builds commands with spec paths" do
+    it 'builds commands with spec paths' do
       expect(Guard::RSpec::Command).to receive(:new).with(%w[spec_path1 spec_path2], kind_of(Hash))
       runner.run(paths)
     end
 
-    it "clears inspector paths if run is success" do
-      expect(inspector).to receive(:clear_paths).with(paths)
-      runner.run(paths)
-    end
-
-    it "notifies failure" do
-      Kernel.stub(:system) { false }
-      expect(Guard::Notifier).to receive(:notify).with('Failed', title: 'RSpec results', image: :failed, priority: 2)
-      runner.run(paths)
-    end
-
-    context "with all_after_pass option and old failed spec paths" do
+    context 'with all_after_pass option' do
       let(:options) { { all_after_pass: true } }
-      before {
-        inspector.stub(:failed_paths) { %w[failed_path] }
-        inspector.stub(:paths).with(paths) { paths }
-      }
 
-      it "re-runs all if run is success" do
+      it 're-runs all if run is success' do
         expect(runner).to receive(:run_all)
         runner.run(paths)
       end
     end
 
-    context "with launchy option" do
+    context 'with launchy option' do
       let(:options) { { launchy: 'launchy_path' } }
+
       before {
         Pathname.stub(:new).with('launchy_path') { double(exist?: true) }
       }
 
-      it "opens Launchy" do
+      it 'opens Launchy' do
         expect(Launchy).to receive(:open).with('launchy_path')
         runner.run(paths)
       end
     end
-  end
 
+    it 'notifies inspector about failed paths' do
+      expect(inspector).to receive(:failed).with([])
+      runner.run(paths)
+    end
+
+    context 'with failed paths' do
+      before {
+        File.stub(:readlines).with(formatter_tmp_file) { %W{Summary\n ./failed_spec.rb:123\n ./other/failed_spec.rb:77\n} }
+      }
+
+      it 'notifies inspector about failed paths' do
+        expect(inspector).to receive(:failed).with(%w[./failed_spec.rb:123 ./other/failed_spec.rb:77])
+        runner.run(paths)
+      end
+    end
+
+    it 'notifies success' do
+      expect(notifier).to receive(:notify).with('Summary')
+      runner.run(paths)
+    end
+
+    it 'notifies failure' do
+      Kernel.stub(:system) { nil }
+      expect(notifier).to receive(:notify_failure)
+      runner.run(paths)
+    end
+  end
 end