guard-rspec 2.1.0 → 4.7.3

data/spec/acceptance/formatter_spec.rb

@@ -0,0 +1,46 @@
+require 'pathname'
+require 'tempfile'
+
+require 'gem_isolator'
+
+RSpec.describe "Formatter test", type: :acceptance do
+  context "when isolated" do
+    before { allow(Kernel).to receive(:system).and_call_original }
+
+    let!(:formatter) { File.expand_path('lib/guard/rspec_formatter.rb') }
+
+    context "when a valid results file path is given" do
+      around do |example|
+        Tempfile.open('results') do |tempfile|
+          @results_file = tempfile.path
+          example.run
+        end
+      end
+
+      context "when a succeeding command is given" do
+        let!(:spec) do
+          File.expand_path('spec/acceptance/fixtures/succeeding_spec.rb')
+        end
+
+        let(:rspec_args) do
+          ['-r', formatter, '-f', 'Guard::RSpecFormatter', spec]
+        end
+
+        context "when guard is not in Gemfile" do
+          let(:gems) { [%w(rspec ~>3.4)] }
+
+          it "works" do
+            GemIsolator.isolate(gems: gems) do |env, isolation|
+              env = env.merge('GUARD_RSPEC_RESULTS_FILE' => @results_file)
+
+              # TODO: I don't know why Travis needs a full path for binaries
+              # for system() to work.
+              rspec = env['PATH'].sub(/:.*/, '/rspec')
+              expect(isolation.system(env, rspec, *rspec_args)).to eq(true)
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require "launchy"
+
+require "guard/compat/test/helper"
+require "guard/rspec/command"
+
+RSpec.describe Guard::RSpec::Command do
+  let(:options) { {} }
+  let(:paths) { %w(path1 path2) }
+  let(:command) { Guard::RSpec::Command.new(paths, options) }
+
+  describe ".initialize" do
+    it "sets paths at the end" do
+      expect(command).to match(/path1 path2$/)
+    end
+
+    it "sets custom failure exit code" do
+      expect(command).to match(/--failure-exit-code 2/)
+    end
+
+    it "sets formatter" do
+      regexp = %r{-r .*/lib/guard/rspec_formatter.rb -f Guard::RSpecFormatter}
+      expect(command).to match(regexp)
+    end
+
+    context "with custom cmd" do
+      let(:options) { { cmd: "rspec -t ~slow" } }
+
+      it "uses custom cmd" do
+        expect(command).to match(/^rspec -t ~slow/)
+      end
+    end
+
+    context "with RSpec defined formatter" do
+      let(:formatters) { [%w(doc output)] }
+
+      before do
+        allow(RSpec::Core::ConfigurationOptions).to receive(:new) do
+          instance_double(RSpec::Core::ConfigurationOptions,
+                          options: { formatters: formatters })
+        end
+      end
+
+      it "uses them" do
+        expect(command).to match(/-f doc -o output/)
+      end
+    end
+
+    context "with no RSpec defined formatter" do
+      before do
+        allow(RSpec::Core::ConfigurationOptions).to receive(:new) do
+          instance_double(RSpec::Core::ConfigurationOptions,
+                          options: { formatters: nil })
+        end
+      end
+
+      it "sets default progress formatter" do
+        expect(command).to match(/-f progress/)
+      end
+    end
+
+    context "with formatter in cmd" do
+      let(:options) { { cmd: "rspec -f doc" } }
+
+      it "sets no other formatters" do
+        expect(command).to match(/-f doc/)
+      end
+    end
+
+    context "with cmd_additional_args" do
+      let(:options) { { cmd: "rspec", cmd_additional_args: "-f progress" } }
+
+      it "uses them" do
+        expect(command).to match(/-f progress/)
+      end
+    end
+
+    context ":chdir option present" do
+      let(:chdir) { "moduleA" }
+      let(:paths) do
+        %w(path1 path2).map { |p| "#{chdir}#{File::Separator}#{p}" }
+      end
+
+      let(:options) do
+        {
+          cmd: "cd #{chdir} && rspec",
+          chdir: chdir
+        }
+      end
+
+      it "strips path of chdir" do
+        expect(command).to match(/path1 path2/)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require "guard/compat/test/helper"
+require "guard/rspec/deprecator"
+
+RSpec.describe Guard::RSpec::Deprecator do
+  let(:options) { {} }
+  let(:deprecator) { Guard::RSpec::Deprecator.new(options) }
+
+  describe "#warns_about_deprecated_options" do
+    describe "handling of environment variable SPEC_OPTS" do
+      it "shows warning if SPEC_OPTS is set" do
+        ENV["SPEC_OPTS"] = "-f p"
+        expect(Guard::Compat::UI).to receive(:warning).with(
+          "The SPEC_OPTS environment variable is present." \
+          " This can conflict with guard-rspec."
+        )
+        deprecator.warns_about_deprecated_options
+        ENV["SPEC_OPTS"] = nil # otherwise other specs pick it up and fail
+      end
+      it "does not show warning if SPEC_OPTS is unset" do
+        expect(Guard::Compat::UI).to_not receive(:warning).with(
+          "The SPEC_OPTS environment variable is present." \
+          " This can conflict with guard-rspec."
+        )
+        deprecator.warns_about_deprecated_options
+      end
+    end
+
+    describe "with version option" do
+      let(:options) { { version: 1 } }
+
+      it "shows deprecation warning" do
+        expect(Guard::Compat::UI).to receive(:warning).with(
+          "Guard::RSpec DEPRECATION WARNING:" \
+          " The :version option is deprecated." \
+          " Only RSpec ~> 2.14 is now supported."
+        )
+        deprecator.warns_about_deprecated_options
+      end
+    end
+
+    describe "with exclude option" do
+      let(:options) { { exclude: "**" } }
+
+      it "shows deprecation warning" do
+        expect(Guard::Compat::UI).to receive(:warning).with(
+          "Guard::RSpec DEPRECATION WARNING:" \
+          " The :exclude option is deprecated." \
+          " Please Guard ignore method instead." \
+          " https://github.com/guard/guard#ignore"
+        )
+        deprecator.warns_about_deprecated_options
+      end
+    end
+
+    %w(color drb fail_fast formatter env bundler binstubs rvm cli
+       spring turnip zeus foreman).each do |option|
+      describe "with #{option} option" do
+        let(:options) { { option.to_sym => 1 } }
+
+        it "shows deprecation warning" do
+          expect(Guard::Compat::UI).to receive(:warning).with(
+            "Guard::RSpec DEPRECATION WARNING: The :#{option} option is" \
+            " deprecated. Please customize the new :cmd option to" \
+            " fit your need."
+          )
+          deprecator.warns_about_deprecated_options
+        end
+      end
+    end
+
+    describe "with keep_failed option" do
+      let(:options) { { keep_failed: true } }
+
+      it "shows deprecation warning" do
+        expect(Guard::Compat::UI).to receive(:warning).with(
+          "Guard::RSpec DEPRECATION WARNING:" \
+          " The :keep_failed option is deprecated." \
+          " Please set new :failed_mode option value to" \
+          " :keep instead." \
+          " https://github.com/guard/guard-rspec#list-of-available-options"
+        )
+        deprecator.warns_about_deprecated_options
+      end
+    end
+
+    describe "with focus_on_failed option" do
+      let(:options) { { focus_on_failed: true } }
+
+      it "shows deprecation warning" do
+        expect(Guard::Compat::UI).to receive(:warning).with(
+          "Guard::RSpec DEPRECATION WARNING:" \
+          " The :focus_on_failed option is deprecated." \
+          " Please set new :failed_mode option value to" \
+          " :focus instead." \
+          " https://github.com/guard/guard-rspec#list-of-available-options"
+        )
+        deprecator.warns_about_deprecated_options
+      end
+    end
+  end
+end

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

@@ -0,0 +1,144 @@
+require "guard/compat/test/helper"
+
+require "guard/rspec/inspectors/base_inspector"
+
+RSpec.describe Guard::RSpec::Inspectors::BaseInspector do
+  let(:options) { { custom: "value", spec_paths: %w(myspec) } }
+  let(:inspector) { Guard::RSpec::Inspectors::BaseInspector.new(options) }
+  let(:paths) { %w(spec/foo_spec.rb spec/bar_spec.rb) }
+
+  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(%w(myspec))
+    end
+  end
+
+  describe "#paths" do
+    it "should not be implemented here" do
+      expect { inspector.paths(paths) }.to raise_error(NotImplementedError)
+    end
+
+    context "specific inspector" do
+      class FooInspector < Guard::RSpec::Inspectors::BaseInspector
+        def paths(paths)
+          _clean(paths)
+        end
+      end
+
+      let(:options) do
+        {
+          chdir: chdir,
+          spec_paths: ["spec"]
+        }
+      end
+      let(:chdir) { nil }
+      let(:inspector) { FooInspector.new(options) }
+
+      subject { inspector.paths(paths) }
+
+      context "with dirs" do
+        let(:paths) { ["spec"] }
+
+        it "returns matching paths" do
+          allow(File).to receive(:directory?).
+            with("spec").and_return(false)
+
+          allow(Dir).to receive(:[]).and_return(["foo"])
+
+          expect(subject).to eq(paths)
+        end
+
+        context "chdir option present" do
+          let(:chdir) { "moduleA" }
+          let(:paths) { ["#{chdir}/spec"] }
+
+          it "returns matching paths" do
+            allow(Dir).to receive(:[]).
+              with("moduleA/spec/**{,/*/**}/*[_.]spec.rb").
+              and_return(paths)
+
+            allow(Dir).to receive(:[]).
+              with("moduleA/spec/**{,/*/**}/*.feature").
+              and_return([])
+
+            allow(File).to receive(:directory?).
+              with("moduleA/spec").and_return(false)
+
+            expect(subject).to eq(paths)
+          end
+        end
+      end
+
+      context "with spec files" do
+        let(:paths) do
+          ["app/models/a_foo.rb", "spec/models/a_foo_spec.rb"]
+        end
+        let(:spec_files) do
+          [["spec/models/a_foo_spec.rb",
+            "spec/models/b_foo_spec.rb"]]
+        end
+
+        it "returns matching paths" do
+          allow(File).to receive(:directory?).with("app/models/a_foo.rb").
+            and_return(false)
+
+          allow(File).to receive(:directory?).with("spec/models/a_foo_spec.rb").
+            and_return(false)
+
+          allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*[_.]spec.rb").
+            and_return(spec_files)
+
+          allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*.feature").
+            and_return([])
+
+          expect(subject).to eq(["spec/models/a_foo_spec.rb"])
+        end
+
+        context "chdir option present" do
+          let(:chdir) { "moduleA" }
+          let(:paths) do
+            ["moduleA/models/a_foo.rb", "spec/models/a_foo_spec.rb"]
+          end
+
+          let(:spec_files) do
+            [["moduleA/spec/models/a_foo_spec.rb",
+              "moduleA/spec/models/b_foo_spec.rb"]]
+          end
+
+          it "returns matching paths" do
+            allow(File).to receive(:directory?).with("moduleA/models/a_foo.rb").
+              and_return(false)
+
+            allow(File).to receive(:directory?).
+              with("spec/models/a_foo_spec.rb").
+              and_return(false)
+
+            allow(Dir).to receive(:[]).
+              with("moduleA/spec/**{,/*/**}/*[_.]spec.rb").
+              and_return(spec_files)
+
+            allow(Dir).to receive(:[]).
+              with("moduleA/spec/**{,/*/**}/*.feature").
+              and_return([])
+
+            expect(subject).to eq(["spec/models/a_foo_spec.rb"])
+          end
+        end
+      end
+    end
+  end
+
+  describe "#failed" do
+    it "should not be implemented here" do
+      expect { inspector.failed(paths) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#reload" do
+    it "should not be implemented here" do
+      expect { inspector.reload }.to raise_error(NotImplementedError)
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require "guard/compat/test/helper"
+
+require "guard/rspec/inspectors/factory"
+
+RSpec.describe Guard::RSpec::Inspectors::Factory do
+  let(:factory) { Guard::RSpec::Inspectors::Factory }
+  let(:options) { {} }
+
+  it "can not be instantiated" do
+    expect { factory.new(options) }.to raise_error(NoMethodError)
+  end
+
+  context "with :focus failed mode and custom options" do
+    let(:options) { { failed_mode: :focus, custom: "value" } }
+
+    it "creates FocusedInspector instance with custom options" do
+      inspector = factory.create(options)
+      expect(inspector).
+        to be_an_instance_of(Guard::RSpec::Inspectors::FocusedInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+
+  context "with :keep failed mode and custom options" do
+    let(:options) { { failed_mode: :keep, custom: "value" } }
+
+    it "creates KeepingInspector instance with custom options" do
+      inspector = factory.create(options)
+      expect(inspector).
+        to be_an_instance_of(Guard::RSpec::Inspectors::KeepingInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+
+  context "with :none failed mode and custom options" do
+    let(:options) { { failed_mode: :none, custom: "value" } }
+
+    it "creates SimpleInspector instance with custom options" do
+      inspector = factory.create(options)
+      expect(inspector).
+        to be_an_instance_of(Guard::RSpec::Inspectors::SimpleInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+require "guard/compat/test/helper"
+
+require "lib/guard/rspec/inspectors/shared_examples"
+
+require "guard/rspec/inspectors/focused_inspector"
+
+klass = Guard::RSpec::Inspectors::FocusedInspector
+
+RSpec.describe klass do
+  include_examples "inspector", klass
+
+  # Use real paths because BaseInspector#_clean will be used to clean them
+  let(:other_paths) do
+    [
+      "spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb",
+      "spec/lib/guard/rspec/runner_spec.rb"
+    ]
+  end
+
+  let(:other_failed_locations) do
+    %w(./spec/lib/guard/rspec/deprecator_spec.rb:446)
+  end
+
+  it "remembers failed paths and returns them until they all pass" 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("myspec/**{,/*/**}/*[_.]spec.rb").
+      and_return([])
+
+    allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*.feature").
+      and_return([])
+
+    allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*.feature").
+      and_return([])
+
+    expect(inspector.paths(paths)).to match_array(paths)
+    inspector.failed(failed_locations)
+
+    # Return failed_locations until they pass
+    3.times do
+      expect(inspector.paths(other_paths)).to match_array(failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths(paths)).to match_array(failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths([])).to match_array(failed_locations)
+      inspector.failed(failed_locations)
+    end
+
+    # Now all pass
+    expect(inspector.paths(paths)).to match_array(failed_locations)
+    inspector.failed([])
+
+    # And some fails again
+    expect(inspector.paths(other_paths)).to match_array(other_paths)
+    inspector.failed(other_failed_locations)
+
+    # Return other_failed_locations until they pass
+    3.times do
+      expect(inspector.paths(other_paths)).
+        to match_array(other_failed_locations)
+
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths(paths)).to match_array(other_failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths([])).to match_array(other_failed_locations)
+      inspector.failed(failed_locations)
+    end
+
+    # Now all pass
+    expect(inspector.paths(paths)).to match_array(other_failed_locations)
+    inspector.failed([])
+
+    expect(inspector.paths(paths)).to match_array(paths)
+    inspector.failed([])
+
+    expect(inspector.paths(other_paths)).to match_array(other_paths)
+    inspector.failed([])
+
+    expect(inspector.paths([])).to eq([])
+  end
+
+  describe "#reload" do
+    it "force to forget about focused 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/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("myspec/**{,/*/**}/*[_.]spec.rb").
+        and_return([])
+
+      allow(Dir).to receive(:[]).with("myspec/**{,/*/**}/*.feature").
+        and_return([])
+
+      allow(Dir).to receive(:[]).with("spec/**{,/*/**}/*.feature").
+        and_return([])
+
+      allow(File).to receive(:directory?).
+        with("spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb").
+        and_return(false)
+
+      expect(inspector.paths(paths)).to match_array(paths)
+      inspector.failed(failed_locations)
+
+      inspector.reload
+      expect(inspector.paths(other_paths)).to match_array(other_paths)
+    end
+  end
+end