Add a callback method for the observer dynamically

I want to create a match that checks if an observer is viewing an observer.

I decided to add the method dynamically after_create

(if needed), save the model instance, and check if it is true that the observer instance received the call after_create

. Simplified version ( full version ):

RSpec::Matchers.define :be_observed_by do |observer_name|
  match do |obj|

    observer.class_eval do
      define_method(:after_create) {}

    observer.instance.should_receive(:after_create) false)


      RSpec::Mocks::verify  # run mock verifications
    rescue RSpec::Mocks::MockExpectationError => e
      # here one can use #{e} to construct an error message


This is not a job. An observer instance is not accepted after_create


But if I change the actual Observer code in app/models/user_observer.rb

like this

class UserObserver
  def after_create end


Works as expected.

What should I do to dynamically add a method after_create

to force a satellite after creation?


source to share

1 answer

In short, this is because Rails hooks UserObserver callbacks to User events during initialization. If after_create

no callback is defined for UserObserver at this point , it will not be called, even if added later.

If you are interested in more details on how this observer initialization and connection to the wobserved class works, I posted a quick overview of the Observer implementation at the end. But before we get to that, here's a way to make your tests work. Now I'm not sure if you want to use this, and not sure why you decided to test the observer behavior in your application in the first place, but for the sake of completeness ...

Once done define_method(:after_create)

for the observer in your matches, inject an explicit call define_callbacks

(protected method, see walking through the Observer implementation below for what it does) on the observer instance. Here is the code:

observer.class_eval do
  define_method(:after_create) { |user| }
observer.instance.instance_eval do          # this is the added code
  define_callbacks(obj.class)               # - || -
end                                         # - || -


A quick overview of the Observer implementation.

Note. I am using "observer rails" gem sources (in Rails 4, observers were moved to an extra gem that is not installed by default). In your case, if you are on Rails 3.x, the implementation details may be different, but I believe the idea would be the same.

First, observer instantiation starts here: . Basically, call ActiveRecord::Base.instantiate_observers

in ActiveSupport.on_load(:active_record)

, that is, when the ActiveRecord library is loaded.

In the same file, you can see how it takes a parameter config.active_record.observers

usually provided in config/application.rb

and passes it to the observers=

one defined here: /observing.rb#L38

But back to ActiveRecord::Base.instantiate_observers

. It just cycles through all the defined observers and calls instantiate_observer

for each of them. Implemented here instantiate_observer

: . Basically, it makes a call Observer.instance

(like a Singleton, the observer has one instance) that initializes that instance if it hasn't already.

This is how the Observer initialization looks like: . That is a challenge add_observer!


You can see add_observer!

along with and define_callbacks

which it calls here: .

This method define_callbacks

goes through all the callbacks defined in your observer class (UserObserver) at the time and creates methods "_notify_#{observer_name}_for_#{callback}"

for the observable class (User) and registers them as triggering this event in the observable class (User, again).

In your case, it should have been a _notify_user_observer_for_after_create

method added as a after_create

callback for the user. Internally, this _notify_user_observer_for_after_create

will call update

in the UserObserver class, which in turn will call after_create

on UserObserver, and everything will work from there.

But in your case, it after_create

doesn't exist at UserObserver

Rails initialization time, so no method is created or registered for the callback User.after_create

. So no luck after that with catching it in your tests. This little secret is being solved.