rubocop-rspec 1.5.2 → 1.5.3

data/spec/rubocop/cop/rspec/instance_variable_spec.rb

@@ -2,49 +2,37 @@ describe RuboCop::Cop::RSpec::InstanceVariable do
   subject(:cop) { described_class.new }
 
   it 'finds an instance variable inside a describe' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do',
-        '  before { @foo = [] }',
-        '  it { expect(@foo).to be_empty }',
-        'end'
-      ]
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([3])
-    expect(cop.messages).to eq(['Use `let` instead of an instance variable'])
+    expect_violation(<<-RUBY)
+      describe MyClass do
+        before { @foo = [] }
+        it { expect(@foo).to be_empty }
+                    ^^^^ Use `let` instead of an instance variable
+      end
+    RUBY
   end
 
   it 'ignores non-spec blocks' do
-    inspect_source(
-      cop,
-      [
-        'not_rspec do',
-        '  before { @foo = [] }',
-        '  it { expect(@foo).to be_empty }',
-        'end'
-      ]
-    )
-    expect(cop.offenses).to be_empty
+    expect_no_violations(<<-RUBY)
+      not_rspec do
+        before { @foo = [] }
+        it { expect(@foo).to be_empty }
+      end
+    RUBY
   end
 
   it 'finds an instance variable inside a shared example' do
-    inspect_source(
-      cop,
-      [
-        "shared_examples 'shared example' do",
-        '  it { expect(@foo).to be_empty }',
-        'end'
-      ]
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([2])
-    expect(cop.messages).to eq(['Use `let` instead of an instance variable'])
+    expect_violation(<<-RUBY)
+      shared_examples 'shared example' do
+        it { expect(@foo).to be_empty }
+                    ^^^^ Use `let` instead of an instance variable
+      end
+    RUBY
   end
 
   it 'ignores an instance variable without describe' do
-    inspect_source(cop, ['@foo = []', '@foo.empty?'])
-    expect(cop.offenses).to be_empty
+    expect_no_violations(<<-RUBY)
+      @foo = []
+      @foo.empty?
+    RUBY
   end
 end

data/spec/rubocop/cop/rspec/multiple_describes_spec.rb

@@ -2,42 +2,27 @@ describe RuboCop::Cop::RSpec::MultipleDescribes do
   subject(:cop) { described_class.new }
 
   it 'finds multiple top level describes with class and method' do
-    inspect_source(
-      cop,
-      [
-        "describe MyClass, '.do_something' do; end",
-        "describe MyClass, '.do_something_else' do; end"
-      ]
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages).to eq(['Do not use multiple top level describes - ' \
-                                'try to nest them.'])
+    expect_violation(<<-RUBY)
+      describe MyClass, '.do_something' do; end
+      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
+      describe MyClass, '.do_something_else' do; end
+    RUBY
   end
 
   it 'finds multiple top level describes only with class' do
-    inspect_source(
-      cop,
-      [
-        'describe MyClass do; end',
-        'describe MyOtherClass do; end'
-      ]
-    )
-    expect(cop.offenses.size).to eq(1)
-    expect(cop.offenses.map(&:line).sort).to eq([1])
-    expect(cop.messages).to eq(['Do not use multiple top level describes - ' \
-                                'try to nest them.'])
+    expect_violation(<<-RUBY)
+      describe MyClass do; end
+      ^^^^^^^^^^^^^^^^ Do not use multiple top level describes - try to nest them.
+      describe MyOtherClass do; end
+    RUBY
   end
 
   it 'skips single top level describe' do
-    inspect_source(
-      cop,
-      [
-        "require 'spec_helper'",
-        '',
-        'describe MyClass do; end'
-      ]
-    )
-    expect(cop.offenses).to be_empty
+    expect_no_violations(<<-RUBY)
+      require 'spec_helper'
+
+      describe MyClass do
+      end
+    RUBY
   end
 end

data/spec/rubocop/cop/rspec/named_subject_spec.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+RSpec.describe RuboCop::Cop::RSpec::NamedSubject do
+  subject(:cop) { described_class.new }
+
+  it 'checks `it` and `specify` for explicit subject usage' do
+    expect_violation(<<-RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+
+        it "is valid" do
+          expect(subject.valid?).to be(true)
+                 ^^^^^^^ Name your test subject if you need to reference it explicitly.
+        end
+
+        specify do
+          expect(subject.valid?).to be(true)
+                 ^^^^^^^ Name your test subject if you need to reference it explicitly.
+        end
+      end
+    RUBY
+  end
+
+  it 'checks before and after for explicit subject usage' do
+    expect_violation(<<-RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+
+        before(:each) do
+          do_something_with(subject)
+                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
+        end
+
+        after do
+          do_something_with(subject)
+                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
+        end
+      end
+    RUBY
+  end
+
+  it 'checks around(:each) for explicit subject usage' do
+    expect_violation(<<-RUBY)
+      RSpec.describe User do
+        subject { described_class.new }
+
+        around(:each) do |test|
+          do_something_with(subject)
+                            ^^^^^^^ Name your test subject if you need to reference it explicitly.
+        end
+      end
+    RUBY
+  end
+
+  it 'ignores subject when not wrapped inside a test' do
+    expect_no_violations(<<-RUBY)
+      def foo
+        it(subject)
+      end
+    RUBY
+  end
+end

data/spec/rubocop/cop/rspec/not_to_not_spec.rb

@@ -5,17 +5,16 @@ describe RuboCop::Cop::RSpec::NotToNot, :config do
     let(:cop_config) { { 'EnforcedStyle' => 'not_to' } }
 
     it 'detects the `to_not` offense' do
-      inspect_source(subject, 'it { expect(false).to_not be_true }')
-
-      expect(subject.messages).to eq(['Prefer `not_to` over `to_not`'])
-      expect(subject.highlights).to eq(['expect(false).to_not be_true'])
-      expect(subject.offenses.map(&:line).sort).to eq([1])
+      expect_violation(<<-RUBY)
+        it { expect(false).to_not be_true }
+             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `not_to` over `to_not`
+      RUBY
     end
 
     it 'detects no offense when using `not_to`' do
-      inspect_source(subject, 'it { expect(false).not_to be_true }')
-
-      expect(subject.messages).to be_empty
+      expect_no_violations(<<-RUBY)
+        it { expect(false).not_to be_true }
+      RUBY
     end
 
     it 'auto-corrects `to_not` to `not_to`' do
@@ -28,17 +27,16 @@ describe RuboCop::Cop::RSpec::NotToNot, :config do
     let(:cop_config) { { 'EnforcedStyle' => 'to_not' } }
 
     it 'detects the `not_to` offense' do
-      inspect_source(subject, 'it { expect(false).not_to be_true }')
-
-      expect(subject.messages).to eq(['Prefer `to_not` over `not_to`'])
-      expect(subject.highlights).to eq(['expect(false).not_to be_true'])
-      expect(subject.offenses.map(&:line).sort).to eq([1])
+      expect_violation(<<-RUBY)
+        it { expect(false).not_to be_true }
+             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Prefer `to_not` over `not_to`
+      RUBY
     end
 
     it 'detects no offense when using `to_not`' do
-      inspect_source(subject, 'it { expect(false).to_not be_true }')
-
-      expect(subject.messages).to be_empty
+      expect_no_violations(<<-RUBY)
+        it { expect(false).to_not be_true }
+      RUBY
     end
 
     it 'auto-corrects `not_to` to `to_not`' do

data/spec/rubocop/cop/rspec/verified_doubles_spec.rb

@@ -2,39 +2,33 @@ describe RuboCop::Cop::RSpec::VerifiedDoubles, :config do
   subject(:cop) { described_class.new(config) }
 
   it 'finds a `double` instead of an `instance_double`' do
-    inspect_source(cop, ['it do',
-                         '  foo = double("Widget")',
-                         'end'])
-    expect(cop.messages)
-      .to eq(['Prefer using verifying doubles over normal doubles.'])
-    expect(cop.highlights).to eq(['double("Widget")'])
-    expect(cop.offenses.map(&:line).sort).to eq([2])
-    expect(cop.offenses.map(&:to_s).sort).to all(
-      eql('C:  2:  9: Prefer using verifying doubles over normal doubles.')
-    )
+    expect_violation(<<-RUBY)
+      it do
+        foo = double("Widget")
+              ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
+      end
+    RUBY
   end
 
   context 'when configuration does not specify IgnoreSymbolicNames' do
     let(:cop_config) { Hash.new }
 
     it 'find doubles whose name is a symbol' do
-      inspect_source(cop, ['it do',
-                           '  foo = double(:widget)',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Prefer using verifying doubles over normal doubles.'])
-      expect(cop.highlights).to eq(['double(:widget)'])
-      expect(cop.offenses.map(&:line).sort).to eq([2])
+      expect_violation(<<-RUBY)
+        it do
+          foo = double(:widget)
+                ^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
+        end
+      RUBY
     end
 
     it 'finds a `spy` instead of an `instance_spy`' do
-      inspect_source(cop, ['it do',
-                           '  foo = spy("Widget")',
-                           'end'])
-      expect(cop.messages)
-        .to eq(['Prefer using verifying doubles over normal doubles.'])
-      expect(cop.highlights).to eq(['spy("Widget")'])
-      expect(cop.offenses.map(&:line).sort).to eq([2])
+      expect_violation(<<-RUBY)
+        it do
+          foo = spy("Widget")
+                ^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
+        end
+      RUBY
     end
   end
 
@@ -42,34 +36,36 @@ describe RuboCop::Cop::RSpec::VerifiedDoubles, :config do
     let(:cop_config) { { 'IgnoreSymbolicNames' => true } }
 
     it 'ignores doubles whose name is a symbol' do
-      inspect_source(cop, ['it do',
-                           '  foo = double(:widget)',
-                           'end'])
-      expect(cop.messages).to be_empty
+      expect_no_violations(<<-RUBY)
+        it do
+          foo = double(:widget)
+        end
+      RUBY
     end
 
     it 'still flags doubles whose name is a string' do
-      inspect_source(cop, ['it do',
-                           '  foo = double("widget")',
-                           'end'])
-
-      expect(cop.messages.first).to eq(
-        'Prefer using verifying doubles over normal doubles.'
-      )
+      expect_violation(<<-RUBY)
+        it do
+          foo = double("widget")
+                ^^^^^^^^^^^^^^^^ Prefer using verifying doubles over normal doubles.
+        end
+      RUBY
     end
   end
 
   it 'ignores doubles without a name' do
-    inspect_source(cop, ['it do',
-                         '  foo = double',
-                         'end'])
-    expect(cop.messages).to be_empty
+    expect_no_violations(<<-RUBY)
+      it do
+        foo = double
+      end
+    RUBY
   end
 
   it 'ignores instance_doubles' do
-    inspect_source(cop, ['it do',
-                         '  foo = instance_double("Foo")',
-                         'end'])
-    expect(cop.messages).to be_empty
+    expect_no_violations(<<-RUBY)
+      it do
+        foo = instance_double("Foo")
+      end
+    RUBY
   end
 end

data/spec/spec_helper.rb

@@ -7,6 +7,8 @@ if ENV['CI']
   CodeClimate::TestReporter.start
 end
 
+Dir.glob(File.expand_path('support/*.rb', __dir__)).map(&method(:require))
+
 RSpec.configure do |config|
   config.order = :random
 
@@ -17,8 +19,11 @@ RSpec.configure do |config|
   config.mock_with :rspec do |mocks|
     mocks.syntax = :expect # Disable `should_receive` and `stub`
   end
+
+  config.include(ExpectViolation)
 end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
+
 require 'rubocop-rspec'

data/spec/support/expect_violation.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'adamantium'
+require 'concord'
+require 'anima'
+
+module ExpectViolation
+  DEFAULT_FILENAME = 'example_spec.rb'.freeze
+
+  # rubocop:disable Metrics/AbcSize
+  def expect_violation(source, filename: DEFAULT_FILENAME)
+    expectation = Expectation.new(source)
+    inspect_source(cop, expectation.source, filename)
+    offenses = cop.offenses.map(&method(:to_assertion)).sort
+
+    if expectation.assertions.empty?
+      raise 'Use expect_no_violations to assert no violations'
+    end
+
+    expect(offenses).to eq(expectation.assertions.sort)
+  end
+
+  def expect_no_violations(source, filename: DEFAULT_FILENAME)
+    inspect_source(cop, source, filename)
+
+    expect(cop.offenses.empty?).to be(true)
+  end
+
+  private
+
+  def to_assertion(offense)
+    Expectation::Assertion.new(
+      message:      offense.message,
+      line_number:  offense.location.line,
+      column_range: offense.location.column_range
+    )
+  end
+
+  class Expectation
+    VIOLATION_LINE_PATTERN = /\A *\^/
+
+    VIOLATION = :violation
+    SOURCE    = :line
+
+    include Adamantium, Concord.new(:string)
+
+    def source
+      source_map.to_s
+    end
+
+    def assertions
+      source_map.assertions
+    end
+
+    private
+
+    def source_map
+      tokens.reduce(Source::BLANK) do |source, (type, tokens)|
+        tokens.reduce(source, :"add_#{type}")
+      end
+    end
+    memoize :source_map
+
+    def tokens
+      string.each_line.chunk do |line|
+        next SOURCE unless line =~ VIOLATION_LINE_PATTERN
+
+        VIOLATION
+      end
+    end
+
+    class Source
+      include Concord.new(:lines)
+
+      BLANK = new([].freeze)
+
+      def add_line(line)
+        self.class.new(lines + [Line.new(text: line, number: lines.size + 1)])
+      end
+
+      def add_violation(violation)
+        self.class.new([*lines[0...-1], lines.last.add_violation(violation)])
+      end
+
+      def to_s
+        lines.map(&:text).join
+      end
+
+      def assertions
+        lines.flat_map(&:assertions)
+      end
+
+      class Line
+        DEFAULTS = { violations: [] }.freeze
+
+        include Anima.new(:text, :number, :violations)
+
+        def initialize(options)
+          super(DEFAULTS.merge(options))
+        end
+
+        def add_violation(violation)
+          with(violations: violations + [violation])
+        end
+
+        def assertions
+          violations.map do |violation|
+            Assertion.parse(
+              text:        violation,
+              line_number: number
+            )
+          end
+        end
+      end
+    end
+
+    class Assertion
+      def self.parse(text:, line_number:)
+        parser = Parser.new(text)
+
+        new(
+          message:      parser.message,
+          column_range: parser.column_range,
+          line_number:  line_number
+        )
+      end
+
+      include Anima.new(:message, :column_range, :line_number),
+              Adamantium,
+              Comparable
+
+      def <=>(other)
+        to_a <=> other.to_a
+      end
+
+      protected
+
+      def to_a
+        [line_number, column_range.first, column_range.last, message]
+      end
+
+      class Parser
+        COLUMN_PATTERN = /^ *(?<carets>\^\^*) (?<message>.+)$/
+
+        include Concord.new(:text), Adamantium
+
+        def column_range
+          Range.new(*match.offset(:carets), true)
+        end
+
+        def message
+          match[:message]
+        end
+
+        private
+
+        def match
+          text.match(COLUMN_PATTERN)
+        end
+        memoize :match
+      end
+
+      private_constant(*constants(false))
+    end
+  end
+end