class RuboCop::Cop::RSpec::Rails::NegationBeValid


expect(foo).to be_invalid
# good
expect(foo).not_to be_valid
# bad
@example EnforcedStyle: be_invalid
expect(foo).not_to be_valid
# good
expect(foo).to be_invalid
# bad
@example EnforcedStyle: not_to (default)
the test target is an instance of ‘ActiveModel::Validations“.
This cop is unsafe because it cannot guarantee that
@safety
Enforces use of `be_invalid` or `not_to` for negated be_valid.

def message(_matcher) 

def message(_matcher)
  format(MSG,
         runner: replaced_runner,
         matcher: replaced_matcher)
end

def offense?(node) 

def offense?(node)
  case style
  when :not_to
    be_invalid?(node)
  when :be_invalid
    not_to?(node)
  end
end

def offense_range(node) 

def offense_range(node)
  node.parent.loc.selector.with(end_pos: node.loc.selector.end_pos)
end

def on_send(node) 

def on_send(node)
  return unless offense?(node.parent)
  add_offense(offense_range(node),
              message: message(node.method_name)) do |corrector|
    corrector.replace(node.parent.loc.selector, replaced_runner)
    corrector.replace(node.loc.selector, replaced_matcher)
  end
end

def replaced_matcher 

def replaced_matcher
  case style
  when :not_to
    'be_valid'
  when :be_invalid
    'be_invalid'
  end
end

def replaced_runner 

def replaced_runner
  case style
  when :not_to
    'not_to'
  when :be_invalid
    'to'
  end
end