Expecting a primitive value as an argument to a method invocation is easy:

expect(object).to receive(:foo).with('arg1', 'arg2')

This expectation would be met with this call:

object.foo('arg1', 'arg2')

But what if the argument is expected to be an object with a given set of methods? E.g. this class with #first_name and #last_name methods:

class Person

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end
  
  attr_reader :first_name, :last_name
  
end

To just test if an argument is a Person, you have several options:

Test that the argument is an instance of a certain class

expect(object).to receive(:foo).with(instance_of(Person))

Test that the argument responds to certain methods

expect(object).to receive(:foo).with(duck_type(:first_name, :last_name))

To also test that the methods return a particular value, use have_attributes:

expect(object).to receive(:foo).with(have_attributes(first_name: 'Hans', last_name: 'Dampf'))

Test that the argument is a certain class and also returns certain values

Use the attached object_having matcher to test both class and method return values:

expect(object).to receive(:foo).with(object_having(Person, first_name: 'Hans', last_name: 'Dampf'))

Test that the argument is equal to another object

Since with tests == equality by default, you might want to define Person#== so you can compare it to other persons:

class Person

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end
  
  def ==(other)
    first_name == other.first_name && last_name == other.last_name
  end
  
end

Then, in your spec:

expect(object).to receive(:foo).with(Person.new(first_name: 'Hans', last_name: 'Dampf'))

Test anything you want with a block

expect(object).to receive(:foo).with do |received_object|
  expect(received_object.first_name).to eq('Hans')
  ...
end

See Rspec: Complex argument expectations for should_receive for more details.

object_having.rb

Henning Koch

makandra.de

Say thanks4

Last edit

2023-01-09

Dominik Schöler

Attachments

object_having.rb

License

Source code in this card is licensed under the MIT License.

Jasmine: Expecting objects as method invocation arguments

To check if a method has been called in Jasmine, you first need to spy on it:

let spy = spyOn(window, 'alert')
codeThatAlerts()
expect(window.alert).toHaveBeenCalledWith('Important message')

To expect an object of a given type, pass th...

Rspec: Complex argument expectations for should_receive

Sometimes you need complex expectations on method arguments like this

SomeApi.should_receive(:find).with(:query => '*foo*', :sort => 'timestamp ASC', :limit => 100).and_return(['some result'])

This is not very flexible, and failure m...

Async control flow in JavaScript: Promises, Microtasks, async/await

Slides for Henning's talk on Sep 21st 2017.

Understanding sync vs. async control flow

Talking to synchronous (or "blocking") API

print('script start')
html = get('/foo')
print(html)
print('script end'...

Machinist's #make breaks on has_many associations when defining method `empty?`

Observed on Rails 2.3 and machinist 1.0.6

Like the title says, when you define the method empty? like in the following example, you may not longer use collection.make.

class Book

  has_many :pages

  def empty?
    pages...

You can use any RSpec matcher to match arguments of method calls

RSpec lets you define the arguments with which you expect a method to be invoked:

subject.should_receive(:say).with('hello')

Sometimes you don't care about the exact arguments. For such cases RSpec comes with [argument constraints](https...

Posted by Henning Koch to makandra dev (2016-05-13 06:51)