Disable observers by default in tests (inspired by No Peeping Toms)

unobservant.rb

module Unobservant
  mattr_accessor :enabled_observers
  mattr_accessor :all_observers_enabled

  self.enabled_observers = Set[]
  self.all_observers_enabled = true

  class <<self
    def enable_all
      self.all_observers_enabled = true
    end

    def disable_all
      self.all_observers_enabled = false
    end

    def enable(observer)
      enabled_observers << observer.to_s.underscore.to_sym
    end

    def enabled?(observer)
      all_observers_enabled || enabled_observers.include?(observer.to_s.underscore.to_sym)
    end

    def disable(observer)
      enabled_observers.delete(observer.to_s.underscore.to_sym)
    end
  end

  module ActiveModelObserver
    extend ActiveSupport::Concern

    included do
      alias_method_chain :update, :enabled_check
    end

    module ClassMethods
      def enable
        Unobservant.enable(self)
        if block_given?
          begin
            yield
          ensure
            disable
          end
        end
      end

      def disable
        Unobservant.disable(self)
      end

      def enabled?
        Unobservant.enabled?(self)
      end
    end

    module InstanceMethods
      def update_with_enabled_check(meth, object)
        update_without_enabled_check(meth, object) if enabled?
      end

      private

      def enabled?
        self.class.enabled?
      end
    end
  end

  module ActiveRecordObserver
    extend ActiveSupport::Concern

    included do
      alias_method_chain :define_callbacks, :update
    end

    module InstanceMethods
      def define_callbacks_with_update(klass)
        observer = self
        observer_name = observer.class.name.underscore.gsub('/', '__')
        ActiveRecord::Callbacks::CALLBACKS.each do |callback|
          next unless respond_to?(callback)
          callback_meth = "_notify_#{observer_name}_for_#{callback}""_notify_#{observer_name}_for_#{callback}"
          unless klass.respond_to?(callback_meth)
            klass.__send__(:define_method, callback_meth) do
              observer.update(callback, self)
            end
            klass.__send__(callback, callback_meth)
          end
        end
      end
    end
  end
end

ActiveModel::Observer.module_eval { include Unobservant::ActiveModelObserver }
ActiveRecord::Observer.module_eval { include Unobservant::ActiveRecordObserver }