guard-rspec 4.3.1 → 4.4.1

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

@@ -1,58 +1,120 @@
-require 'spec_helper'
-
-shared_examples 'inspector' do |klass|
-  let(:spec_paths) { %w[spec myspec] }
-  let(:options) { { custom: 'value', spec_paths: spec_paths } }
+RSpec.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
+  let(:paths) do
+    [
+      "spec/lib/guard/rspec/inspectors/base_inspector_spec.rb",
+      "spec/lib/guard/rspec/runner_spec.rb",
+      "spec/lib/guard/rspec/deprecator_spec.rb"
+    ]
+  end
+  let(:failed_locations) do
+    [
+      "./spec/lib/guard/rspec/runner_spec.rb:12",
+      "./spec/lib/guard/rspec/deprecator_spec.rb:55"
+    ]
+  end
+
+  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.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
+  describe "#paths" do
+    before do
+      allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*[_.]spec.rb").
+        and_return([])
+
+      allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*.feature").
+        and_return([])
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*.feature").
+        and_return([])
+    end
+
+    it "returns paths when called first time" do
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/inspectors/base_inspector_spec.rb").
+        and_return(false)
+
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/runner_spec.rb").
+        and_return(false)
+
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/deprecator_spec.rb").
+        and_return(false)
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+        and_return(paths)
+
       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]
+    it "does not return non-spec paths" do
+      paths = %w(not_a_spec_path.rb spec/not_exist_spec.rb)
+
+      allow(File).to receive(:directory?).with("not_a_spec_path.rb").
+        and_return(false)
+
+      allow(File).to receive(:directory?).with("spec/not_exist_spec.rb").
+        and_return(false)
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+        and_return([])
+
       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)
+    it "uniq and compact paths" do
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/inspectors/base_inspector_spec.rb").
+        and_return(false)
+
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/runner_spec.rb").
+        and_return(false)
+
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/deprecator_spec.rb").
+        and_return(false)
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+        and_return(paths)
+
+      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'])
+    it "return spec_paths and directories too" do
+      allow(File).to receive(:directory?).with("myspec").and_return(true)
+      allow(File).to receive(:directory?).with("lib/guard").and_return(true)
+      allow(File).to receive(:directory?).
+        with("not_exist_dir").and_return(false)
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+        and_return([])
+
+      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
+  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
+  describe "#reload" do
+    it "is callable" do
       expect { inspector.reload }.not_to raise_error
     end
   end

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

@@ -1,23 +1,59 @@
-require 'spec_helper'
-require 'lib/guard/rspec/inspectors/shared_examples'
+require "guard/compat/test/helper"
+
+require "lib/guard/rspec/inspectors/shared_examples"
+
+require "guard/rspec/inspectors/simple_inspector"
 
 klass = Guard::RSpec::Inspectors::SimpleInspector
 
-describe klass do
-  include_examples 'inspector', klass
+RSpec.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
+  let(:other_paths) do
+    [
+      "spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb",
+      "spec/lib/guard/rspec/runner_spec.rb"
+    ]
+  end
+
+  it "returns paths and do not bothers about failed locations" do
+    allow(File).to receive(:directory?).
+      with("spec/lib/guard/rspec/inspectors/base_inspector_spec.rb").
+      and_return(false)
+
+    allow(File).to receive(:directory?).
+      with("spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb").
+      and_return(false)
+
+    allow(File).to receive(:directory?).
+      with("spec/lib/guard/rspec/runner_spec.rb").
+      and_return(false)
+
+    allow(File).to receive(:directory?).
+      with("spec/lib/guard/rspec/deprecator_spec.rb").
+      and_return(false)
+
+    allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+      and_return(paths + other_paths)
+
+    allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*.feature").
+      and_return([])
+
+    allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*[_.]spec.rb").
+      and_return([])
+
+    allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*.feature").
+      and_return([])
+
+    expect(inspector.paths(paths)).to eq(paths)
+    inspector.failed(failed_locations)
+    expect(inspector.paths(other_paths)).to eq(other_paths)
+    inspector.failed([])
+
+    expect(inspector.paths(paths)).to eq(paths)
+    inspector.failed(failed_locations)
+    expect(inspector.paths(other_paths)).to eq(other_paths)
+    inspector.failed([])
   end
 end

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

@@ -1,68 +1,90 @@
-require 'spec_helper'
+require "guard/compat/test/helper"
 
-describe Guard::RSpec::Notifier do
-  let(:options) { { notification: true } }
+require "guard/rspec/notifier"
+
+RSpec.describe Guard::RSpec::Notifier do
+  let(:options) { { notification: true, title: "RSpec results" } }
   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 })
+  def expect_notification(title = "RSpec results", message, image, priority)
+    expect(Guard::Notifier).
+      to receive(:notify).
+      with(message,  title: title, image: image, priority: priority)
   end
 
-  describe '#notify_failure' do
-    it 'notifies about failure' do
-      expect_notification('Failed', :failed, 2)
+  describe "#notify_failure" do
+    it "notifies about failure" do
+      expect_notification("Failed", :failed, 2)
       notifier.notify_failure
     end
+
+    context "with a custom title" do
+      let(:options) { { notification: true, title: "Failure title" } }
+
+      it "notifies with the title" do
+        expect_notification("Failure title", "Failed", :failed, 2)
+        notifier.notify_failure
+      end
+    end
   end
 
-  describe '#notify' do
-    it 'notifies about success' do
-      expect_notification('This is summary', :success, -2)
-      notifier.notify('This is summary')
+  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' }
+    context "with pendings" do
+      let(:summary) { "5 examples, 0 failures (1 pending) in 4.0000 seconds" }
 
-      it 'notifies about pendings' do
+      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' }
+    context "with failures" do
+      let(:summary) { "5 examples, 1 failures in 4.0000 seconds" }
 
-      it 'notifies about failures' do
+      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' }
+      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
+        it "still notifies about failures" do
           expect_notification(summary, :failed, 2)
           notifier.notify(summary)
         end
       end
     end
+
+    context "with a custom title" do
+      let(:options) { { notification: true, title: "Custom title" } }
+
+      it "notifies with the title" do
+        expect_notification("Custom title", "This is summary", :success, -2)
+        notifier.notify("This is summary")
+      end
+    end
   end
 
-  context 'with notifications turned off' do
+  context "with notifications turned off" do
     let(:options) { { notification: false } }
 
-    describe '#notify_failure' do
-      it 'keeps quiet' do
+    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
+    describe "#notify" do
+      it "keeps quiet" do
         expect(Guard::Notifier).not_to receive(:notify)
-        notifier.notify('Summary')
+        notifier.notify("Summary")
       end
     end
   end

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

@@ -1,195 +1,238 @@
-require 'spec_helper'
-require 'launchy'
+require "guard/compat/test/helper"
 
-describe Guard::RSpec::Runner do
-  let(:options) { {cmd: 'rspec'} }
+require "launchy"
+
+require "guard/rspec/runner"
+
+RSpec.describe Guard::RSpec::Runner do
+  let(:options) { { cmd: "rspec" } }
   let(:runner) { Guard::RSpec::Runner.new(options) }
   let(:inspector) { double(Guard::RSpec::Inspectors::SimpleInspector) }
   let(:notifier) { double(Guard::RSpec::Notifier) }
-  let(:formatter_tmp_file) { Guard::RSpec::Formatter::TEMPORARY_FILE_PATH }
-  before {
+
+  before do
     allow(Guard::UI).to receive(:info)
     allow(Kernel).to receive(:system) { true }
     allow(Guard::RSpec::Inspectors::Factory).to receive(:create) { inspector }
     allow(Guard::RSpec::Notifier).to receive(:new) { notifier }
-    allow(Guard::RSpec::Command).to receive(:new) { 'rspec' }
+    allow(Guard::RSpec::Command).to receive(:new) { "rspec" }
     allow(notifier).to receive(:notify)
     allow(notifier).to receive(:notify_failure)
-  }
 
-  describe '.initialize' do
-    context 'with custom options' do
+    $CHILD_STATUS = double("exitstatus", exitstatus: 0)
+  end
+
+  describe ".initialize" do
+    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)
+      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
+      it "instanciates notifier with custom options" do
         expect(Guard::RSpec::Notifier).to receive(:new).with(foo: :bar)
         runner
       end
     end
   end
 
-  describe '#reload' do
+  describe "#reload" do
     it 'calls inspector\'s #reload' do
       expect(inspector).to receive(:reload)
       runner.reload
     end
   end
 
-  shared_examples 'abort' do
-    it 'aborts' do
+  shared_examples "abort" do
+    it "aborts" do
       expect(Guard::UI).to_not receive(:info)
       subject
     end
 
-    it 'returns true' do
+    it "returns true" do
       expect(subject).to be true
     end
   end
 
-  describe '#run_all' do
-    let(:options) { {
-      spec_paths: %w[spec1 spec2],
-      cmd: 'rspec',
-      run_all: { message: 'Custom message' }
-    } }
-    before { allow(inspector).to receive(:failed) }
+  describe "#run_all" do
+    let(:options) do
+      {
+        spec_paths: %w(spec1 spec2),
+        cmd: "rspec",
+        run_all: { message: "Custom message" }
+      }
+    end
 
-    it 'builds commands with spec paths' do
-      expect(Guard::RSpec::Command).to receive(:new).with(%w[spec1 spec2], kind_of(Hash))
+    before do
+      allow(inspector).to receive(:failed)
+      allow(File).to receive(:readlines).and_return([])
+    end
+
+    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
 
-    it 'prints message' do
-      expect(Guard::UI).to receive(:info).with('Custom message', reset: true)
+    it "prints message" do
+      expect(Guard::UI).to receive(:info).with("Custom message", reset: true)
       runner.run_all
     end
 
-    context 'when no paths are given' do
+    context "when no paths are given" do
       subject { runner.run_all }
 
-      let(:options) { {
-        spec_paths: [],
-        run_all: { message: 'Custom message' }
-      } }
+      let(:options) do
+        {
+          spec_paths: [],
+          run_all: { message: "Custom message" }
+        }
+      end
 
-      include_examples 'abort'
+      include_examples "abort"
     end
 
-    context 'with custom cmd' do
-      before {
-        options[:run_all][:cmd] = 'rspec -t ~slow'
-      }
+    context "with custom cmd" do
+      before do
+        options[:run_all][:cmd] = "rspec -t ~slow"
+      end
 
-      it 'builds command with custom cmd' do
-        expect(Guard::RSpec::Command).to receive(:new).with(kind_of(Array), hash_including(cmd: 'rspec -t ~slow'))
+      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
 
-    context 'with no cmd' do
-      before {
+    context "with no cmd" do
+      before do
         options[:cmd] = nil
         allow(Guard::RSpec::Command).to receive(:new)
         allow(Guard::UI).to receive(:error).with(an_instance_of(String))
         allow(notifier).to receive(:notify_failure)
         runner.run_all
-      }
+      end
 
-      it 'does not build' do
+      it "does not build" do
         expect(Guard::RSpec::Command).to_not have_received(:new)
       end
 
-      it 'issues a warning to the user' do
+      it "issues a warning to the user" do
         expect(Guard::UI).to have_received(:error).with(an_instance_of(String))
       end
 
-      it 'notifies the notifer of failure' do
+      it "notifies the notifer of failure" do
         expect(notifier).to have_received(:notify_failure)
       end
     end
   end
 
-  describe '#run' do
-    let(:paths) { %w[spec_path1 spec_path2] }
-    before {
-      allow(File).to receive(:readlines).with(formatter_tmp_file) { %W{Summary\n} }
+  describe "#run" do
+    let(:paths) { %w(spec_path1 spec_path2) }
+    before do
+      tmp_file = "tmp/rspec_guard_result"
+      allow(File).to receive(:readlines).with(tmp_file) { ["Summary\n"] }
       allow(inspector).to receive(:paths) { paths }
       allow(inspector).to receive(:clear_paths) { true }
       allow(inspector).to receive(:failed)
-    }
+    end
 
-    it 'prints running message' do
-      expect(Guard::UI).to receive(:info).with('Running: spec_path1 spec_path2', reset: true)
+    it "prints running message" do
+      expect(Guard::UI).to receive(:info).
+        with("Running: spec_path1 spec_path2", reset: true)
       runner.run(paths)
     end
 
-    context 'when no paths are given' do
+    context "when no paths are given" do
       subject { runner.run([]) }
 
       before do
         allow(inspector).to receive(:paths) { [] }
       end
 
-      include_examples 'abort'
+      include_examples "abort"
     end
 
-    it 'builds commands with spec paths' do
-      expect(Guard::RSpec::Command).to receive(:new).with(%w[spec_path1 spec_path2], kind_of(Hash))
+    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
 
-    context 'with all_after_pass option' do
-      let(:options) { { cmd: 'rspec', all_after_pass: true } }
+    context "with all_after_pass option" do
+      let(:options) { { cmd: "rspec", all_after_pass: true } }
 
-      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
-      let(:options) { { cmd: 'rspec', launchy: 'launchy_path' } }
+    context "with launchy option" do
+      let(:options) { { cmd: "rspec", launchy: "launchy_path" } }
 
-      before {
-        allow(Pathname).to receive(:new).with('launchy_path') { double(exist?: true) }
-      }
+      before do
+        allow(Pathname).to receive(:new).
+          with("launchy_path") { double(exist?: true) }
+      end
 
-      it 'opens Launchy' do
-        expect(Launchy).to receive(:open).with('launchy_path')
+      it "opens Launchy" do
+        expect(Launchy).to receive(:open).with("launchy_path")
         runner.run(paths)
       end
     end
 
-    it 'notifies inspector about failed paths' do
+    it "notifies inspector about failed paths" do
       expect(inspector).to receive(:failed).with([])
       runner.run(paths)
     end
 
-    context 'with failed paths' do
-      before {
-        allow(File).to receive(:readlines).with(formatter_tmp_file) { %W{Summary\n ./failed_spec.rb:123\n ./other/failed_spec.rb:77\n} }
-      }
+    context "with failed paths" do
+      before do
+        allow(File).to receive(:readlines).
+          with("tmp/rspec_guard_result") do
+          [
+            "Summary\n",
+            "./failed_spec.rb:123\n",
+            "./other/failed_spec.rb:77\n"
+          ]
+        end
+      end
+      it "notifies inspector about failed paths" do
+        expect(inspector).to receive(:failed).
+          with(["./failed_spec.rb:123", "./other/failed_spec.rb:77"])
 
-      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')
+    it "notifies success" do
+      expect(notifier).to receive(:notify).with("Summary")
       runner.run(paths)
     end
 
-    it 'notifies failure' do
+    it "notifies failure" do
       allow(Kernel).to receive(:system) { nil }
       expect(notifier).to receive(:notify_failure)
       runner.run(paths)
     end
   end
+
+  # TODO: remove / cleanup
+  describe "_tmp_file" do
+    subject { described_class.new.send(:_tmp_file, chdir) }
+
+    context "with no chdir option" do
+      let(:chdir) { nil }
+      it { is_expected.to eq("tmp/rspec_guard_result") }
+    end
+
+    context "chdir option" do
+      let(:chdir) { "moduleA" }
+      it { is_expected.to eq("moduleA/tmp/rspec_guard_result") }
+    end
+  end
 end