graph_mediator 0.2.1

data/spec/investigation/module_super_spec.rb

@@ -0,0 +1,88 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module ModuleSuperSpec # namespacing
+
+describe "module super" do
+
+  before(:each) do
+    module Baz
+      def baz
+        'baz'
+      end
+    end
+ 
+    module Bar
+      def bar
+        'bar'
+      end
+    end
+ 
+    class AbstractFoo
+      def deeper_foo
+        'deeper_foo'
+      end
+    end
+    
+    class Foo < AbstractFoo
+      include Baz
+      include Bar
+      def foo
+        'foo'
+      end
+    end
+  end
+
+  after(:each) do
+    ModuleSuperSpec.__send__(:remove_const, :Baz)
+    ModuleSuperSpec.__send__(:remove_const, :Bar)
+    ModuleSuperSpec.__send__(:remove_const, :Foo)
+    ModuleSuperSpec.__send__(:remove_const, :AbstractFoo)
+  end
+
+  it "should basically work" do
+    f = Foo.new
+    f.foo.should == 'foo'
+    f.deeper_foo.should == 'deeper_foo'
+    f.bar.should == 'bar'
+    f.baz.should == 'baz'
+  end
+
+  it "should override baz and retain a reference to original in a module" do
+    Bar.class_eval do
+      def baz
+        super
+      end
+      alias_method :baz_original, :baz
+      def baz
+        super + ' barred'
+      end
+    end
+    f = Foo.new
+    f.foo.should == 'foo'
+    f.deeper_foo.should == 'deeper_foo'
+    f.bar.should == 'bar'
+    f.baz.should == 'baz barred'
+    # ruby 1.8 issue (see insert_subclass_spec.rb as well)
+    # http://redmine.ruby-lang.org/issues/show/734
+    lambda { f.baz_original }.should raise_error(NoMethodError)
+  end
+
+  it "cannot alias a method higher up the chain from a module" do
+    lambda { Bar.class_eval do
+      alias_method :baz_original, :baz
+    end }.should raise_error(NameError)
+  end
+
+  it "can call super from a method override in a module" do
+    Bar.class_eval do
+      def baz
+        super + ' barred from module'
+      end
+    end
+    f = Foo.new
+    f.baz.should == "baz barred from module"
+  end
+
+end
+
+end

data/spec/investigation/self_decorating.rb

@@ -0,0 +1,55 @@
+class SelfDecorating
+
+  module Secret
+    @@methods_to_alias = []
+    def self.extended(base)
+      unless @@methods_to_alias.empty?
+        # only needs to be done once
+        @@methods_to_alias.each do |target| 
+          without_method = "#{target}_without_secret"
+          klass = base.class
+          method_defined_here = (klass.instance_methods(false) + klass.private_instance_methods(false)).include?(RUBY_VERSION < '1.9' ? target.to_s : target)
+          unless method_defined_here 
+            klass.send(:define_method, target) do |*args, &block|
+              super
+            end
+          end
+          unless klass.method_defined?(without_method)
+            klass.send(:alias_method, without_method, target)
+          end
+        end
+        @@methods_to_alias.clear
+      end
+    end
+  
+    def foo
+      'foo'
+    end
+
+    def self.methods_to_alias
+      @@methods_to_alias
+    end
+  end
+
+  def self.new
+    c = super
+    return c.extend SelfDecorating::Secret
+  end
+
+  def self.decorate(method)
+    Secret.class_eval do
+# Error raised calling super from an aliased method included from a module where
+# method is declared (Ruby 1.8)
+# http://redmine.ruby-lang.org/issues/show/734
+#      define_method(method) do |*args,&block|
+#        super
+#      end
+#      alias_method "#{method}_without_secret", method
+      define_method(method) do |*args,&block|
+        super + ' with secret'
+      end
+      methods_to_alias << method
+    end 
+  end
+end
+

data/spec/mediator_spec.rb

@@ -0,0 +1,201 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe "GraphMediator::Mediator" do
+  
+  before(:each) do
+    load_traceable_callback_tester
+    @t = Traceable.new(:name => :gizmo)
+    @t.save_without_mediation!
+    @m = @t.__send__(:_get_mediator)
+  end
+
+  after(:each) do
+    Object.__send__(:remove_const, :Traceable)
+  end
+
+  it "should raise error if initialized with something that is not a GraphMediator" do
+    lambda { GraphMediator::Mediator.new(:foo) }.should raise_error(ArgumentError)
+  end
+
+  it "should transition through states" do
+    @m.should be_idle
+    @m.start!
+    @m.should be_mediating
+    @m.bump!
+    @m.should be_versioning
+    @m.done!
+    @m.should be_idle
+    @m.disable!
+    @m.should be_disabled
+    @m.done!
+    @m.should be_idle
+  end
+
+  it "should reflect mediation_enabled of mediated_instance" do
+    @m.mediation_enabled?.should be_true
+    @t.disable_mediation!
+    @m.mediation_enabled?.should be_false
+  end
+
+  it "should only perform a single after_mediation even with nested mediated_transactions" do
+    @m.mediate { @m.mediate { } }
+    @traceables_callbacks.should == [:before, :reconcile, :cache]
+  end
+
+  it "should capture changes" do
+    @m.changes.should == {}
+    @t.name = :foo
+    @t.should be_changed
+    @m.track_changes_for(@t)
+    @m.changes.should == {Traceable => { @t.id => { 'name'=> [:gizmo, :foo] }}}
+  end
+
+  it "should not blow the stack if attempt a transaction in before_create" do
+    begin
+      Traceable.before_create { |i| i.mediated_transaction { i.callbacks << :before_create } }
+      t = Traceable.new(:name => :foo)
+      # lambda { t.save! }.should raise_error(GraphMediator::MediatorException)
+      t.save!
+      @traceables_callbacks.should == [:before, :before_create, :reconcile, :cache]
+    ensure
+      Traceable.before_create_callback_chain.clear
+    end
+  end
+
+  it "should reset to idle state if an error is thrown before mediation" do
+    class << @t
+      def before; raise; end
+    end
+    lambda { @m.mediate {} }.should raise_error(RuntimeError)
+    @m.aasm_current_state.should == :idle
+  end
+
+  it "should reset to idle state if an error is thrown during mediation" do
+    lambda { @m.mediate { raise } }.should raise_error(RuntimeError)
+    @m.aasm_current_state.should == :idle
+  end
+
+  it "should reset to idle state if an error is thrown after mediation" do
+    class << @t
+      def reconcile; raise; end
+    end
+    lambda { @m.mediate {} }.should raise_error(RuntimeError)
+    @m.aasm_current_state.should == :idle
+  end
+
+  it "should reset to idle state if an error is thrown when cacheing" do
+    class << @t
+      def cache; raise; end
+    end
+    lambda { @m.mediate {} }.should raise_error(RuntimeError)
+    @m.aasm_current_state.should == :idle
+  end
+  
+  it "should reset to idle state if an error is thrown when versioning" do
+    class << @t
+      def touch; raise; end
+    end
+    lambda { @m.mediate {} }.should raise_error(RuntimeError)
+    @m.aasm_current_state.should == :idle
+  end
+
+  context "when enabling and disabling mediation" do
+  
+    it "should continue to mediate if mediation disabled part way through" do
+      @m.mediation_enabled?.should be_true
+      @t.should_receive(:reconcile).once
+      @m.mediate do
+        @t.disable_mediation!
+        @m.mediate do
+          # should not begin a new transaction 
+        end
+      end
+    end
+
+    it "should continue as disabled if mediation enabled part way through" do
+      @t.disable_mediation!
+      @m.mediation_enabled?.should be_false
+      @t.should_not_receive(:reconcile)
+      @m.mediate do 
+        @t.enable_mediation!
+        @m.mediate do
+          # should not begin a new transaction 
+        end
+      end
+    end
+
+  end
+
+  context "with a GraphMediator::Mediator::ChangesHash" do
+  
+    before(:each) do
+      @ch = GraphMediator::Mediator::ChangesHash.new
+    end
+ 
+    it "should capture changes for new objects" do
+      @ch << Traceable.new
+      @ch.should == { Traceable => { :_created => [ {} ] } }
+    end
+
+    it "should capture changes for changed objects" do
+      @t.name = :bar
+      @ch << @t
+      @ch.should == { Traceable => { @t.id => { 'name' => [:gizmo, :bar] } } }
+    end
+
+    it "should capture changes for destroyed objects" do
+      @t.destroy
+      @ch << @t
+      @ch.should == { Traceable => { :_destroyed => [@t.id] } }
+    end
+ 
+    it "should answer questions about changed attributes" do
+      @t.name = :bar
+      @ch << @t
+      @ch.changed_name?.should be_true
+      @ch.changed_frotz?.should be_false
+    end
+ 
+    it "should answer questions about multiple changed attributes" do
+      @t.name = :bar
+      @t.state = :frotzed
+      @ch << @t
+      @ch.all_changed?(:name, :state).should be_true
+      @ch.all_changed?(:name, :number).should be_false
+      @ch.any_changed?(:name, :number).should be_true
+    end
+
+    it "should answer questions about dependents not in the changes hash" do
+      @ch.should == {}
+      @ch.added_dependent?(Traceable).should == false
+      @ch.destroyed_dependent?(Traceable).should == false
+      @ch.altered_dependent?(Traceable).should == false
+      @ch.touched_any_dependent?(Traceable).should == false
+    end
+ 
+    it "should answer questions about added dependents" do
+      new_t = Traceable.new(:name => :dependent)
+      @ch << new_t
+      @ch.added_dependent?(Traceable).should be_true
+      @ch.added_or_destroyed_dependent?(Traceable).should be_true
+      @ch.touched_any_dependent?(Traceable).should be_true
+    end
+
+    it "should answer questions about deleted dependents" do
+      @t.destroy
+      @ch << @t
+      @ch.destroyed_dependent?(Traceable).should be_true
+      @ch.added_or_destroyed_dependent?(Traceable).should be_true
+      @ch.touched_any_dependent?(Traceable).should be_true
+    end
+
+    it "should answer questions about changed dependents" do
+      @t.name = :bar
+      @ch << @t
+      @ch.altered_dependent?(Traceable).should be_true
+      @ch.added_or_destroyed_dependent?(Traceable).should be_false
+      @ch.touched_any_dependent?(Traceable).should be_true
+    end
+
+  end
+end

data/spec/reservations/lodging.rb

@@ -0,0 +1,4 @@
+class Lodging < ActiveRecord::Base
+  belongs_to :reservation, :counter_cache => true
+  has_many :party_lodgings
+end

data/spec/reservations/party.rb

@@ -0,0 +1,4 @@
+class Party < ActiveRecord::Base
+  belongs_to :reservation, :counter_cache => true
+  has_many :party_lodgings
+end

data/spec/reservations/party_lodging.rb

@@ -0,0 +1,4 @@
+class PartyLodging < ActiveRecord::Base
+  belongs_to :party, :counter_cache => true
+  belongs_to :lodging, :counter_cache => true
+end

data/spec/reservations/reservation.rb

@@ -0,0 +1,18 @@
+class Reservation < ActiveRecord::Base
+  has_many :parties
+  has_many :lodgings
+  has_many :party_lodgings, :through => :lodgings
+
+  include GraphMediator
+  mediate :dependencies => [Lodging, Party], 
+    :when_reconciling => :reconcile,
+    :when_cacheing => :cache
+
+  def lodge(party, options = {})
+    lodging = options[:in]
+    party.party_lodgings.create(:lodging_id => lodging)
+  end
+
+  def reconcile; :reconcile; end
+  def cache; :cache; end
+end

data/spec/reservations/schema.rb

@@ -0,0 +1,33 @@
+create_schema do |connection|
+  connection.create_table(:reservations, :force => true) do |t|
+    t.string :name
+    t.date :starts
+    t.date :ends
+    t.integer :parties_count
+    t.integer :lodgings_count
+    t.integer :lock_version, :default => 0
+    t.timestamps
+  end
+  
+  connection.create_table(:parties, :force => true) do |t|
+    t.string :name
+    t.belongs_to :reservation
+    t.integer :party_lodgings_count
+    t.timestamps
+  end
+  
+  connection.create_table(:lodgings, :force => true) do |t|
+    t.integer :room_number
+    t.decimal :rate
+    t.belongs_to :reservation
+    t.date :date
+    t.integer :party_lodgings_count
+    t.timestamps
+  end
+  
+  connection.create_table(:party_lodgings, :force => true) do |t|
+    t.belongs_to :party
+    t.belongs_to :lodging
+    t.timestamps
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,3 @@
+--color
+--format nested
+--diff

data/spec/spec_helper.rb

@@ -0,0 +1,65 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'graph_mediator'
+require 'spec'
+require 'spec/autorun'
+require 'pp'
+
+require 'database'
+
+class TestLogger
+  [:debug, :info, :warn, :error].each do |m|
+    define_method(m) { |message| puts "#{m.to_s.upcase}: #{message}" }
+  end
+end
+
+Spec::Runner.configure do |config|
+
+  # Ensures each listed class is cleared from the objectspace and reloaded.
+  # RSpec does not reload classes between tests, so if you're testing class
+  # variables/class instance variables, they accumulate state between tests.
+  # Also a problem if you mock a class method.
+  def reload_classes(*classes) 
+    classes.each do |constant|
+      md = constant.to_s.match(/^(.*?)(?:::)?([^:]+)$/)
+      klass = (matched_both = md.captures.size == 2) ? md[2] : md[1]
+      namespace = md[1] if matched_both
+      (namespace.try(:constantize) || Object).send(:remove_const, klass.to_s.to_sym)
+    end
+    classes.each do |constant|
+      load "#{constant.to_s.underscore}.rb"
+    end
+  end
+
+  # Provides a class Traceable which records calls in @traceables_callbacks
+  def load_traceable_callback_tester
+    create_schema do |conn|
+      conn.create_table(:traceables, :force => true) do |t|
+        t.string :name
+        t.string :state
+        t.integer :number
+        t.integer :lock_version, :default => 0
+        t.timestamps
+      end
+    end
+
+    # make sure we record all callback calls regardless of which instance we're in.
+    @traceables_callbacks = callbacks_ref = []
+    c = Class.new(ActiveRecord::Base)
+    Object.const_set(:Traceable, c)
+    c.class_eval do
+      include GraphMediator
+       
+      mediate :when_reconciling => :reconcile, :when_cacheing => :cache
+      before_mediation :before
+
+      validates_presence_of :name
+   
+      def before; callbacks << :before; end
+      def reconcile; callbacks << :reconcile; end
+      def cache; callbacks << :cache; end
+      define_method(:callbacks) { callbacks_ref }
+    end
+  end
+
+end