Michael Hartl的RoR教程第11章中的Rspec方法“ be_following”

Question

I'm wondering where this method 'be_following' from chapter 11 came from? Here's the snippet from the user_spec:

describe "following" do
  it { should be_following(other_user) }
  its(:followed_users) { should include(other_user) }

  describe "followed user" do
    subject { other_user }
    its(:followers) { should include(@user) }
  end
end

I don't understand how this method is created. As far as I know it's not a default rspec or capybara method. I'm not even sure whether or not in rspec you can use the rails generated methods from when you define model relationships such as has_many and belongs_to. Is that so? And why in this case is there the method be_following when that is not even defined in the models. Here's the User model:

has_many :years
has_many :relationships, dependent: :destroy, foreign_key: :follower_id
has_many :followed_users, through: :relationships, source: :followed
has_many :reverse_relationships, foreign_key: "followed_id",
                               class_name:  "Relationship",
                               dependent:   :destroy
has_many :followers, through: :reverse_relationships, source: :follower

def User.new_remember_token
    SecureRandom.urlsafe_base64
end

def User.encrypt(token)
    Digest::SHA1.hexdigest(token.to_s)
end

def following?(followed)
    relationships.find_by_followed_id(followed)
end

def follow!(followed)
    relationships.create!(:followed_id => followed.id)
end

def unfollow!(other_user)
    relationships.find_by(followed_id: other_user.id).destroy!
end

Answer 1

RSpec has build-in dynamic matchers for methods with '?' at the end.

Ex.: if object responds to following? then you'll be able to write test like

it {object.should be_following}

The same works if you need to pass parameter to the method.

Documentation: https://www.relishapp.com/rspec/rspec-expectations/v/2-0/docs/matchers/predicate-matchers

Some more examples:

class A
  def has_anything?; true end
  def has_smth?(a); !a.nil?  end
  def nice?; true end
  def as_nice_as?(x); x == :unicorn end
end

describe A do
  it {should have_anything}
  it {should have_smth(42)}
  it {should be_nice}
  it {should be_as_nice_as(:unicorn)}
  it {should_not be_as_nice_as(:crocodile)}
end

So it's be_, be_a_, be_an_ for any method ending with '?' and have_ for has_...? methods. Params are passed like:

should be_like(:ruby)

Custom matchers are used for more complecated checks with ability to customize success and failure messages.