rails-observers 0.1.2 → 0.1.5

data/test/lifecycle_test.rb

@@ -1,249 +0,0 @@
-require 'helper'
-
-class SpecialDeveloper < Developer; end
-
-class DeveloperObserver < ActiveRecord::Observer
-  def calls
-    @calls ||= []
-  end
-
-  def before_save(developer)
-    calls << developer
-  end
-end
-
-class SalaryChecker < ActiveRecord::Observer
-  observe :special_developer
-  attr_accessor :last_saved
-
-  def before_save(developer)
-    return developer.salary > 80000
-  end
-
-  module Implementation
-    def after_save(developer)
-      self.last_saved = developer
-    end
-  end
-  include Implementation
-end
-
-class TopicaAuditor < ActiveRecord::Observer
-  observe :topic
-
-  attr_reader :topic
-
-  def after_find(topic)
-    @topic = topic
-  end
-end
-
-class TopicObserver < ActiveRecord::Observer
-  attr_reader :topic
-
-  def after_find(topic)
-    @topic = topic
-  end
-
-  # Create an after_save callback, so a notify_observer hook is created
-  # on :topic.
-  def after_save(nothing)
-  end
-end
-
-class MinimalisticObserver < ActiveRecord::Observer
-  attr_reader :minimalistic
-
-  def after_find(minimalistic)
-    @minimalistic = minimalistic
-  end
-end
-
-class MultiObserver < ActiveRecord::Observer
-  attr_reader :record
-
-  def self.observed_class() [ Topic, Developer ] end
-
-  cattr_reader :last_inherited
-  @@last_inherited = nil
-
-  def observed_class_inherited_with_testing(subclass)
-    observed_class_inherited_without_testing(subclass)
-    @@last_inherited = subclass
-  end
-
-  alias_method_chain :observed_class_inherited, :testing
-
-  def after_find(record)
-    @record = record
-  end
-end
-
-class ValidatedComment < Comment
-  attr_accessor :callers
-
-  before_validation :record_callers
-
-  after_validation do
-    record_callers
-  end
-
-  def record_callers
-    callers << self.class if callers
-  end
-end
-
-class ValidatedCommentObserver < ActiveRecord::Observer
-  attr_accessor :callers
-
-  def after_validation(model)
-    callers << self.class if callers
-  end
-end
-
-
-class AroundTopic < Topic
-end
-
-class AroundTopicObserver < ActiveRecord::Observer
-  observe :around_topic
-  def topic_ids
-    @topic_ids ||= []
-  end
-
-  def around_save(topic)
-    topic_ids << topic.id
-    yield(topic)
-    topic_ids << topic.id
-  end
-end
-
-class LifecycleTest < ActiveRecord::TestCase
-  fixtures :topics, :developers, :minimalistics
-
-  def test_before_destroy
-    topic = Topic.find(1)
-    assert_difference 'Topic.count', -(1 + topic.replies.size) do
-      topic.destroy
-    end
-  end
-
-  def test_auto_observer
-    topic_observer = TopicaAuditor.instance
-    assert_nil TopicaAuditor.observed_class
-    assert_equal [Topic], TopicaAuditor.observed_classes.to_a
-
-    topic = Topic.find(1)
-    assert_equal topic.title, topic_observer.topic.title
-  end
-
-  def test_inferred_auto_observer
-    topic_observer = TopicObserver.instance
-    assert_equal Topic, TopicObserver.observed_class
-
-    topic = Topic.find(1)
-    assert_equal topic.title, topic_observer.topic.title
-  end
-
-  def test_observing_two_classes
-    multi_observer = MultiObserver.instance
-
-    topic = Topic.find(1)
-    assert_equal topic.title, multi_observer.record.title
-
-    developer = Developer.find(1)
-    assert_equal developer.name, multi_observer.record.name
-  end
-
-  def test_observing_subclasses
-    multi_observer = MultiObserver.instance
-
-    developer = SpecialDeveloper.find(1)
-    assert_equal developer.name, multi_observer.record.name
-
-    klass = Class.new(Developer)
-    assert_equal klass, multi_observer.last_inherited
-
-    developer = klass.find(1)
-    assert_equal developer.name, multi_observer.record.name
-  end
-
-  def test_after_find_can_be_observed_when_its_not_defined_on_the_model
-    observer = MinimalisticObserver.instance
-    assert_equal Minimalistic, MinimalisticObserver.observed_class
-
-    minimalistic = Minimalistic.find(1)
-    assert_equal minimalistic, observer.minimalistic
-  end
-
-  def test_after_find_can_be_observed_when_its_defined_on_the_model
-    observer = TopicObserver.instance
-    assert_equal Topic, TopicObserver.observed_class
-
-    topic = Topic.find(1)
-    assert_equal topic, observer.topic
-  end
-
-  def test_invalid_observer
-    assert_raise(ArgumentError) { Topic.observers = Object.new; Topic.instantiate_observers }
-  end
-
-  test "model callbacks fire before observers are notified" do
-    callers = []
-
-    comment = ValidatedComment.new
-    comment.callers = ValidatedCommentObserver.instance.callers = callers
-
-    comment.valid?
-    assert_equal [ValidatedComment, ValidatedComment, ValidatedCommentObserver], callers,
-      "model callbacks did not fire before observers were notified"
-  end
-
-  test "able to save developer" do
-    SalaryChecker.instance # activate
-    developer = SpecialDeveloper.new :name => 'Roger', :salary => 100000
-    assert developer.save, "developer with normal salary failed to save"
-  end
-
-  test "unable to save developer with low salary" do
-    SalaryChecker.instance # activate
-    developer = SpecialDeveloper.new :name => 'Rookie', :salary => 50000
-    assert !developer.save, "allowed to save a developer with too low salary"
-  end
-
-  test "able to call methods defined with included module" do # https://rails.lighthouseapp.com/projects/8994/tickets/6065-activerecordobserver-is-not-aware-of-method-added-by-including-modules
-    SalaryChecker.instance # activate
-    developer = SpecialDeveloper.create! :name => 'Roger', :salary => 100000
-    assert_equal developer, SalaryChecker.instance.last_saved
-  end
-
-  test "around filter from observer should accept block" do
-    observer = AroundTopicObserver.instance
-    topic = AroundTopic.new
-    topic.save
-    assert_nil observer.topic_ids.first
-    assert_not_nil observer.topic_ids.last
-  end
-
-  test "able to disable observers" do
-    observer = DeveloperObserver.instance # activate
-    observer.calls.clear
-
-    ActiveRecord::Base.observers.disable DeveloperObserver do
-      Developer.create! :name => 'Ancestor', :salary => 100000
-      SpecialDeveloper.create! :name => 'Descendent', :salary => 100000
-    end
-
-    assert_equal [], observer.calls
-  end
-
-  def test_observer_is_called_once
-    observer = DeveloperObserver.instance # activate
-    observer.calls.clear
-
-    developer = Developer.create! :name => 'Ancestor', :salary => 100000
-    special_developer = SpecialDeveloper.create! :name => 'Descendent', :salary => 100000
-
-    assert_equal [developer, special_developer], observer.calls
-  end
-end

data/test/models/observers.rb

@@ -1,27 +0,0 @@
-class ORM
-  include ActiveModel::Observing
-
-  def save
-    notify_observers :before_save
-  end
-
-  class Observer < ActiveModel::Observer
-    def before_save_invocations
-      @before_save_invocations ||= []
-    end
-
-    def before_save(record)
-      before_save_invocations << record
-    end
-  end
-end
-
-class Widget < ORM; end
-class Budget < ORM; end
-class WidgetObserver < ORM::Observer; end
-class BudgetObserver < ORM::Observer; end
-class AuditTrail < ORM::Observer
-  observe :widget, :budget
-end
-
-ORM.instantiate_observers

data/test/observer_array_test.rb

@@ -1,222 +0,0 @@
-require 'minitest/autorun'
-require 'active_model'
-require 'rails/observers/active_model/active_model'
-require 'models/observers'
-
-class ObserverArrayTest < ActiveModel::TestCase
-  def teardown
-    ORM.observers.enable :all
-    Budget.observers.enable :all
-    Widget.observers.enable :all
-  end
-
-  def assert_observer_notified(model_class, observer_class)
-    observer_class.instance.before_save_invocations.clear
-    model_instance = model_class.new
-    model_instance.save
-    assert_equal [model_instance], observer_class.instance.before_save_invocations
-  end
-
-  def assert_observer_not_notified(model_class, observer_class)
-    observer_class.instance.before_save_invocations.clear
-    model_instance = model_class.new
-    model_instance.save
-    assert_equal [], observer_class.instance.before_save_invocations
-  end
-
-  test "all observers are enabled by default" do
-    assert_observer_notified Widget, WidgetObserver
-    assert_observer_notified Budget, BudgetObserver
-    assert_observer_notified Widget, AuditTrail
-    assert_observer_notified Budget, AuditTrail
-  end
-
-  test "can disable individual observers using a class constant" do
-    ORM.observers.disable WidgetObserver
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_notified     Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can enable individual observers using a class constant" do
-    ORM.observers.disable :all
-    ORM.observers.enable AuditTrail
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_notified     Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can disable individual observers using a symbol" do
-    ORM.observers.disable :budget_observer
-
-    assert_observer_notified     Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_notified     Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can enable individual observers using a symbol" do
-    ORM.observers.disable :all
-    ORM.observers.enable :audit_trail
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_notified     Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can disable multiple observers at a time" do
-    ORM.observers.disable :widget_observer, :budget_observer
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_notified     Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can enable multiple observers at a time" do
-    ORM.observers.disable :all
-    ORM.observers.enable :widget_observer, :budget_observer
-
-    assert_observer_notified     Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_not_notified Budget, AuditTrail
-  end
-
-  test "can disable all observers using :all" do
-    ORM.observers.disable :all
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_not_notified Budget, AuditTrail
-  end
-
-  test "can enable all observers using :all" do
-    ORM.observers.disable :all
-    ORM.observers.enable :all
-
-    assert_observer_notified Widget, WidgetObserver
-    assert_observer_notified Budget, BudgetObserver
-    assert_observer_notified Widget, AuditTrail
-    assert_observer_notified Budget, AuditTrail
-  end
-
-  test "can disable observers on individual models without affecting those observers on other models" do
-    Widget.observers.disable :all
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can enable observers on individual models without affecting those observers on other models" do
-    ORM.observers.disable :all
-    Budget.observers.enable AuditTrail
-
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_not_notified Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "can disable observers for the duration of a block" do
-    yielded = false
-    ORM.observers.disable :budget_observer do
-      yielded = true
-      assert_observer_notified     Widget, WidgetObserver
-      assert_observer_not_notified Budget, BudgetObserver
-      assert_observer_notified     Widget, AuditTrail
-      assert_observer_notified     Budget, AuditTrail
-    end
-
-    assert yielded
-    assert_observer_notified Widget, WidgetObserver
-    assert_observer_notified Budget, BudgetObserver
-    assert_observer_notified Widget, AuditTrail
-    assert_observer_notified Budget, AuditTrail
-  end
-
-  test "can enable observers for the duration of a block" do
-    yielded = false
-    Widget.observers.disable :all
-
-    Widget.observers.enable :all do
-      yielded = true
-      assert_observer_notified Widget, WidgetObserver
-      assert_observer_notified Budget, BudgetObserver
-      assert_observer_notified Widget, AuditTrail
-      assert_observer_notified Budget, AuditTrail
-    end
-
-    assert yielded
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-
-  test "raises an appropriate error when a developer accidentally enables or disables the wrong class (i.e. Widget instead of WidgetObserver)" do
-    assert_raise ArgumentError do
-      ORM.observers.enable :widget
-    end
-
-    assert_raise ArgumentError do
-      ORM.observers.enable Widget
-    end
-
-    assert_raise ArgumentError do
-      ORM.observers.disable :widget
-    end
-
-    assert_raise ArgumentError do
-      ORM.observers.disable Widget
-    end
-  end
-
-  test "allows #enable at the superclass level to override #disable at the subclass level when called last" do
-    Widget.observers.disable :all
-    ORM.observers.enable :all
-
-    assert_observer_notified Widget, WidgetObserver
-    assert_observer_notified Budget, BudgetObserver
-    assert_observer_notified Widget, AuditTrail
-    assert_observer_notified Budget, AuditTrail
-  end
-
-  test "allows #disable at the superclass level to override #enable at the subclass level when called last" do
-    Budget.observers.enable :audit_trail
-    ORM.observers.disable :audit_trail
-
-    assert_observer_notified     Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_not_notified Budget, AuditTrail
-  end
-
-  test "can use the block form at different levels of the hierarchy" do
-    yielded = false
-    Widget.observers.disable :all
-
-    ORM.observers.enable :all do
-      yielded = true
-      assert_observer_notified Widget, WidgetObserver
-      assert_observer_notified Budget, BudgetObserver
-      assert_observer_notified Widget, AuditTrail
-      assert_observer_notified Budget, AuditTrail
-    end
-
-    assert yielded
-    assert_observer_not_notified Widget, WidgetObserver
-    assert_observer_notified     Budget, BudgetObserver
-    assert_observer_not_notified Widget, AuditTrail
-    assert_observer_notified     Budget, AuditTrail
-  end
-end
-

data/test/observing_test.rb

@@ -1,183 +0,0 @@
-require 'minitest/autorun'
-require 'active_model'
-require 'rails/observers/active_model/active_model'
-
-class ObservedModel
-  include ActiveModel::Observing
-
-  class Observer
-  end
-end
-
-class FooObserver < ActiveModel::Observer
-  class << self
-    public :new
-  end
-
-  attr_accessor :stub
-
-  def on_spec(record, *args)
-    stub.event_with(record, *args) if stub
-  end
-
-  def around_save(record)
-    yield :in_around_save
-  end
-end
-
-class Foo
-  include ActiveModel::Observing
-end
-
-class ObservingTest < ActiveModel::TestCase
-  def setup
-    ObservedModel.observers.clear
-  end
-
-  test "initializes model with no cached observers" do
-    assert ObservedModel.observers.empty?, "Not empty: #{ObservedModel.observers.inspect}"
-  end
-
-  test "stores cached observers in an array" do
-    ObservedModel.observers << :foo
-    assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
-  end
-
-  test "flattens array of assigned cached observers" do
-    ObservedModel.observers = [[:foo], :bar]
-    assert ObservedModel.observers.include?(:foo), ":foo not in #{ObservedModel.observers.inspect}"
-    assert ObservedModel.observers.include?(:bar), ":bar not in #{ObservedModel.observers.inspect}"
-  end
-
-  test "uses an ObserverArray so observers can be disabled" do
-    ObservedModel.observers = [:foo, :bar]
-    assert ObservedModel.observers.is_a?(ActiveModel::ObserverArray)
-  end
-
-  test "instantiates observer names passed as strings" do
-    ObservedModel.observers << 'foo_observer'
-    FooObserver.expects(:instance)
-    ObservedModel.instantiate_observers
-  end
-
-  test "instantiates observer names passed as symbols" do
-    ObservedModel.observers << :foo_observer
-    FooObserver.expects(:instance)
-    ObservedModel.instantiate_observers
-  end
-
-  test "instantiates observer classes" do
-    ObservedModel.observers << ObservedModel::Observer
-    ObservedModel::Observer.expects(:instance)
-    ObservedModel.instantiate_observers
-  end
-
-  test "raises an appropriate error when a developer accidentally adds the wrong class (i.e. Widget instead of WidgetObserver)" do
-    assert_raise ArgumentError do
-      ObservedModel.observers = ['string']
-      ObservedModel.instantiate_observers
-    end
-    assert_raise ArgumentError do
-      ObservedModel.observers = [:string]
-      ObservedModel.instantiate_observers
-    end
-    assert_raise ArgumentError do
-      ObservedModel.observers = [String]
-      ObservedModel.instantiate_observers
-    end
-  end
-
-  test "passes observers to subclasses" do
-    FooObserver.instance
-    bar = Class.new(Foo)
-    assert_equal Foo.observers_count, bar.observers_count
-  end
-end
-
-class ObserverTest < ActiveModel::TestCase
-  def setup
-    ObservedModel.observers = :foo_observer
-    FooObserver.singleton_class.instance_eval do
-      alias_method :original_observed_classes, :observed_classes
-    end
-  end
-
-  def teardown
-    FooObserver.singleton_class.instance_eval do
-      undef_method :observed_classes
-      alias_method :observed_classes, :original_observed_classes
-    end
-  end
-
-  test "guesses implicit observable model name" do
-    assert_equal Foo, FooObserver.observed_class
-  end
-
-  test "tracks implicit observable models" do
-    instance = FooObserver.new
-    assert_equal [Foo], instance.observed_classes
-  end
-
-  test "tracks explicit observed model class" do
-    FooObserver.observe ObservedModel
-    instance = FooObserver.new
-    assert_equal [ObservedModel], instance.observed_classes
-  end
-
-  test "tracks explicit observed model as string" do
-    FooObserver.observe 'observed_model'
-    instance = FooObserver.new
-    assert_equal [ObservedModel], instance.observed_classes
-  end
-
-  test "tracks explicit observed model as symbol" do
-    FooObserver.observe :observed_model
-    instance = FooObserver.new
-    assert_equal [ObservedModel], instance.observed_classes
-  end
-
-  test "calls existing observer event" do
-    foo = Foo.new
-    FooObserver.instance.stub = stub
-    FooObserver.instance.stub.expects(:event_with).with(foo)
-    Foo.notify_observers(:on_spec, foo)
-  end
-
-  test "calls existing observer event from the instance" do
-    foo = Foo.new
-    FooObserver.instance.stub = stub
-    FooObserver.instance.stub.expects(:event_with).with(foo)
-    foo.notify_observers(:on_spec)
-  end
-
-  test "passes extra arguments" do
-    foo = Foo.new
-    FooObserver.instance.stub = stub
-    FooObserver.instance.stub.expects(:event_with).with(foo, :bar)
-    Foo.send(:notify_observers, :on_spec, foo, :bar)
-  end
-
-  test "skips nonexistent observer event" do
-    foo = Foo.new
-    Foo.notify_observers(:whatever, foo)
-  end
-
-  test "update passes a block on to the observer" do
-    yielded_value = nil
-    FooObserver.instance.update(:around_save, Foo.new) do |val|
-      yielded_value = val
-    end
-    assert_equal :in_around_save, yielded_value
-  end
-
-  test "observe redefines observed_classes class method" do
-    class BarObserver < ActiveModel::Observer
-      observe :foo
-    end
-
-    assert_equal [Foo], BarObserver.observed_classes
-
-    BarObserver.observe(ObservedModel)
-    assert_equal [ObservedModel], BarObserver.observed_classes
-  end
-end