where_missing_spec.rb

# frozen_string_literal: true

RSpec.describe RuboCop::Cop::Rails::WhereMissing, :config do
  context 'Rails 6.1', :rails61 do
    it 'registers an offense when using `left_joins(foo).where(foos: {id: nil})`' do
      expect_offense(<<~RUBY)
        Foo.left_joins(:foo).where(foos: { id: nil }).where(bar: "bar")
            ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `left_outer_joins(foo).where(foos: {id: nil})`' do
      expect_offense(<<~RUBY)
        Foo.left_outer_joins(:foo).where(foos: { id: nil }).where(bar: "bar")
            ^^^^^^^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_outer_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `where(foos: {id: nil}).left_joins(foo)`' do
      expect_offense(<<~RUBY)
        Foo.where(foos: { id: nil }).left_joins(:foo).where(bar: "bar")
                                     ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).where(bar: "bar")
      RUBY
    end

    it "registers an offense when using `left_joins(foo).where(foos: {id: nil}, bar: 'bar')`" do
      expect_offense(<<~RUBY)
        Foo.left_joins(:foo).where(foos: { id: nil }, bar: "bar")
            ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).where(bar: "bar")
      RUBY
    end

    it "registers an offense when using `left_joins(foo).where(bar: 'bar', foos: {id: nil})`" do
      expect_offense(<<~RUBY)
        Foo.left_joins(:foo).where(bar: "bar", foos: { id: nil })
            ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `where(foos: {id: nil}).joins(:bar).left_joins(foo)`' do
      expect_offense(<<~RUBY)
        Foo.left_joins(:foo).joins(:bar).where(foos: { id: nil })
            ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo).joins(:bar)
      RUBY
    end

    it 'registers an offense when using `left_joins(foo).where(foos: {id: nil})` with multi-line leading ' \
       'dot method calls' do
      expect_offense(<<~RUBY)
        Foo
          .left_joins(:foo)
           ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
          .where(foos: { id: nil })
          .where(bar: "bar")
      RUBY

      expect_correction(<<~RUBY)
        Foo
          .where.missing(:foo)
          .where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `left_joins(foo).where(foos: {id: nil})` with multi-line trailing ' \
       'dot method calls' do
      expect_offense(<<~RUBY)
        Foo.
          left_joins(:foo).
          ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
          where(foos: { id: nil }).
          where(bar: "bar")
      RUBY

      expect_correction(<<~RUBY)
        Foo.
          where.missing(:foo).
          where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `left_joins(foo).where(foos: {id: nil})` and there is a line break after' \
       '`left_joins.where`' do
      expect_offense(<<~RUBY)
        Foo.left_joins(:foo).where(foos: { id: nil })
            ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
          .where(bar: "bar")
      RUBY

      expect_correction(<<~RUBY)
        Foo.where.missing(:foo)
          .where(bar: "bar")
      RUBY
    end

    it 'registers an offense when using `left_joins(foo).where(foos: {id: nil})` and there is a line break after' \
       '`left_joins.where` and receiver' do
      expect_offense(<<~RUBY)
        Foo
          .left_joins(:foo).where(foos: { id: nil })
           ^^^^^^^^^^^^^^^^ Use `where.missing(:foo)` instead of `left_joins(:foo).where(foos: { id: nil })`.
          .where(bar: "bar")
      RUBY

      expect_correction(<<~RUBY)
        Foo
          .where.missing(:foo)
          .where(bar: "bar")
      RUBY
    end

    it 'does not register an offense when not finding missing relationship records`' do
      expect_no_offenses(<<~RUBY)
        Foo.left_joins(:foo).where(bazs: { id: nil })
        Foo.left_joins(:foo).where(foos: { name: nil })
        Foo.left_joins(:foo).where(foos: { id: 1 })
        Foo.left_joins(foo: :bar).where(bars: { id: nil })
      RUBY
    end
  end

  context 'Rails 6.0', :rails60 do
    it 'does not register an offense when using `left_joins(foo).where(foos: {id: nil})`' do
      expect_no_offenses(<<~RUBY)
        Foo.left_joins(:foo).where(foos: { id: nil }).where(bar: "bar")
      RUBY
    end

    it 'does not register an offense when using `left_outer_joins(foo).where(foos: {id: nil})`' do
      expect_no_offenses(<<~RUBY)
        Foo.left_outer_joins(:foo).where(foos: { id: nil }).where(bar: "bar")
      RUBY
    end
  end
end