graph_mediator 0.2.1

data/spec/integration/threads_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "mediated_transactions in different threads" do
+
+  before(:all) do
+    ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => 'thread-test'})
+  end
+
+  after(:all) do
+    ActiveRecord::Base.establish_connection({'adapter' => 'sqlite3', 'database' => ':memory:'})
+  end
+
+  before(:each) do
+    load_traceable_callback_tester
+    @t = Traceable.new(:name => :gizmo)
+    @t.save_without_mediation! 
+  end
+
+  after(:each) do
+    Object.__send__(:remove_const, :Traceable)
+  end
+
+  # This will produce two warnings regarding overlapping transactions
+  it "should be different instances" do
+    objectid1, objectid2 = nil, nil
+    mediator1, mediator2 = nil, nil
+
+#    puts 'start thread 1'
+    thread1 = Thread.new do
+      t1 = Traceable.find(@t.id)
+#      puts 'preparing to mediate transaction on thread 1'
+      mediator1 = t1.__send__(:_get_mediator)
+#      puts 'mediating transaction on thread 1'
+      Kernel.sleep(2)
+#      puts 'thread 1 finished'
+    end
+
+#    puts 'sleeping kernel 1'
+    Kernel.sleep(1)
+
+#    puts 'start thread 2'
+    thread2 = Thread.new do
+        t2 = Traceable.find(@t.id)
+#        puts 'preparing to mediate transaction on thread 2'
+        mediator2 = t2.__send__(:_get_mediator)
+#        puts 'mediating transaction on thread 2'
+        Kernel.sleep(1)
+#        puts 'thread 2 finished'
+    end
+
+#    puts 'finishing thread 1'
+    thread1.join
+#    puts 'finishing thread 2'
+    thread2.join
+#    pp mediator1, mediator2
+    mediator1.should_not equal(mediator2)
+  end
+
+end

data/spec/integration/validation_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe "GraphMediator validation scenarios" do
+
+  before(:each) do
+    load_traceable_callback_tester
+  end
+
+  after(:each) do
+    Object.__send__(:remove_const, :Traceable)
+  end
+
+  it "should not call after_mediation if validation fails" do
+    t = Traceable.new
+    t.save.should == false
+    @traceables_callbacks.should == [:before]
+  end
+
+end

data/spec/investigation/alias_method_chain_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module AliasMethodChainSpec # namespacing
+
+describe "alias method chain" do
+
+  module ModifiedAliasMethodChain
+    # From Tammo Freese's patch:
+    # https://rails.lighthouseapp.com/projects/8994/tickets/285-alias_method_chain-limits-extensibility
+    def alias_method_chain(target, feature)
+      punctuation = nil
+      with_method, without_method = "#{target}_with_#{feature}#{punctuation}", "#{target}_without_#{feature}#{punctuation}"
+      
+      method_defined_here = (instance_methods(false) + private_instance_methods(false)).include?(RUBY_VERSION < '1.9' ? target.to_s : target)
+      unless method_defined_here
+        module_eval <<-EOS
+          def #{target}(*args, &block)
+            super
+          end
+        EOS
+      end  
+      
+      alias_method without_method, target
+  #    alias_method target, with_method
+      
+      target_method_exists = (instance_methods + private_instance_methods).include?(RUBY_VERSION < '1.9' ? with_method : with_method.to_sym) 
+      raise NameError unless target_method_exists
+      
+      module_eval <<-EOS
+        def #{target}(*args, &block)
+          self.__send__(:'#{with_method}', *args, &block)
+        end
+      EOS
+    end
+  end
+  
+  module BasicAliasMethodChain
+    def alias_method_chain(target, feature)
+      punctuation = nil
+      with_method, without_method = "#{target}_with_#{feature}#{punctuation}", "#{target}_without_#{feature}#{punctuation}"
+      alias_method without_method, target
+      alias_method target, with_method
+    end
+  end
+  
+  module Bar
+    def bar
+      'bar'
+    end
+  end
+
+  module Baz
+    def baz
+      'baz'
+    end
+  end
+  
+  module BazWithLess
+    def self.included(base)
+      base.alias_method_chain :baz, :less
+    end
+  
+    def baz_with_less
+      baz_without_less + ' less'
+    end
+  end
+  
+  class Foo
+    extend ModifiedAliasMethodChain
+    include Bar
+  
+    def foo_with_more
+      foo_without_more + ' more' 
+    end
+  
+    def foo
+      'foo'
+    end
+    alias_method_chain :foo, :more
+  
+    def bar_with_less
+      bar_without_less + ' less'
+    end
+    alias_method_chain :bar, :less
+  
+    include Baz
+    include BazWithLess
+  end
+  
+  class FooBasic
+    extend BasicAliasMethodChain
+    include Bar
+  
+    def foo_with_more
+      foo_without_more + ' more' 
+    end
+  
+    def foo
+      'foo'
+    end
+    alias_method_chain :foo, :more
+  
+    def bar_with_less
+      bar_without_less + ' less'
+    end
+    alias_method_chain :bar, :less
+  
+    include Baz
+    include BazWithLess
+  end
+
+  it "test modified alias method chain" do
+    f = Foo.new
+    f.foo.should == 'foo more'
+    f.foo_without_more.should == 'foo'
+    f.foo_with_more.should == 'foo more'
+    f.bar.should == 'bar less'
+    f.bar_without_less.should == 'bar'
+    f.bar_with_less.should == 'bar less'     
+    f.baz.should == 'baz less'
+    f.baz_without_less.should == 'baz'
+    f.baz_with_less.should == 'baz less'
+    Bar.class_eval do
+      def bar
+        'new bar'
+      end
+    end
+    f.bar.should == 'new bar less'
+    f.bar_without_less.should == 'new bar'
+    f.bar_with_less.should == 'new bar less'
+    Foo.class_eval do
+      def baz_with_less
+        'lesser' 
+      end
+    end
+    f.baz_without_less.should == 'baz'
+    f.baz_with_less.should == 'lesser'
+    f.baz.should == 'lesser'
+  end
+
+  it "test basic alias method chain" do
+    f = FooBasic.new
+    f.foo.should == 'foo more'
+    f.foo_without_more.should == 'foo'
+    f.foo_with_more.should == 'foo more'
+    f.bar.should == 'bar less'
+    f.bar_without_less.should == 'bar'
+    f.bar_with_less.should == 'bar less'
+    Bar.class_eval do
+      def bar
+        'new bar'
+      end
+    end
+    # no change
+    f.bar.should == 'bar less'
+    f.bar_without_less.should == 'bar'
+    f.bar_with_less.should == 'bar less'
+    Foo.class_eval do
+      def baz_with_less
+        raise
+      end
+    end
+    # no error
+    f.baz_without_less.should == 'baz'
+    f.baz_with_less.should == 'baz less'
+    f.baz.should == 'baz less'
+  end
+end
+
+end

data/spec/investigation/insert_subclass_spec.rb

@@ -0,0 +1,122 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+require 'investigation/self_decorating'
+
+module DecoratingSubclassSpec # namespacing
+
+describe "Decorating by extending object eigenclass" do
+
+  module Other
+  
+    def dingo
+      super
+    end
+    # super fails in dingo_without_other (see above)
+    alias_method :dingo_without_other, :dingo
+  
+    def dingo
+      super + " other"
+    end
+  
+    def bat
+      'bat'
+    end
+  end
+  
+  class SuperClass 
+    def dingo
+      'dingo'
+    end
+  end
+  
+  def reload_bar
+    Object.send(:remove_const, :Bar) if Object.const_defined?(:Bar)
+    instance_eval <<EOS
+  module ::Bar
+    def bar
+      'modular bar'
+    end
+  end
+EOS
+  end
+  
+  class SubClass < SuperClass; end
+
+  before(:each) do
+    reload_bar
+  end
+
+  after(:all) do
+    Object.__send__(:remove_const, :Bar)
+  end
+
+  it "should extend Foo::Secret" do
+    f = SelfDecorating.new
+    f.foo.should == 'foo'
+  end
+
+  context "with a new SelfDecorating" do
+
+    before(:each) do
+      load('investigation/self_decorating.rb')
+    end
+
+    after(:each) do
+      Object.send(:remove_const, :SelfDecorating)
+    end
+
+    it "should be able to decorate methods in base after they are defined" do
+      SelfDecorating.send(:define_method, :bar) { 'bar' }
+      SelfDecorating.decorate :bar
+      f = SelfDecorating.new
+      f.bar.should == 'bar with secret'
+      f.bar_without_secret.should == 'bar'
+    end
+
+    it "should be able to decorate methods in Secret before they are defined" do
+      SelfDecorating.decorate :bar
+      SelfDecorating.send(:define_method, :bar) { 'bar' }
+      f = SelfDecorating.new
+      f.bar.should == 'bar with secret'
+      f.bar_without_secret.should == 'bar'
+    end
+
+    it "should not interfere with overrides in superclasses" do
+      SelfDecorating.class_eval { include Bar }
+      SelfDecorating.decorate :bar
+      f = SelfDecorating.new
+      f.bar.should == 'modular bar with secret'
+      f.bar_without_secret.should == 'modular bar'
+      Bar.class_eval { def bar; 'new bar'; end }
+      f.bar_without_secret.should == 'new bar'
+      f.bar.should == 'new bar with secret'
+    end
+
+    it "should not interfere with overrides in the base class" do
+      SelfDecorating.class_eval do
+        include Bar
+        def bar
+          "locally " + super
+        end
+      end
+      SelfDecorating.decorate :bar
+      f = SelfDecorating.new
+      f.bar.should == 'locally modular bar with secret'
+      f.bar_without_secret.should == 'locally modular bar'
+    end
+
+  end
+
+  it "should test overriding superclass methods in a module" do
+    s = SubClass.new
+    s.dingo.should == 'dingo'
+    SubClass.send(:include, Other)
+    s.dingo.should == 'dingo other'
+    # 1.8 bug - aliased method that calls super in a module
+    # http://redmine.ruby-lang.org/issues/show/734
+    lambda { s.dingo_without_other }.should raise_error(NoMethodError)
+    s.bat.should == 'bat'
+  end
+end
+
+end

data/spec/investigation/insert_superclass_spec.rb

@@ -0,0 +1,131 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+module InsertingSuperClassSpec # namespacing
+
+describe "insert superclass" do
+
+  module Decorator
+    def decorate(*methods)
+      methods.each do |m|
+        alias_method "#{m}_without_decoration", m
+        define_method(m) do |*args,&block|
+          super + " decorated" 
+        end
+      end
+    end 
+  end
+  
+  def reload_foo
+    [:Bar, :Foo, :SubFoo].each { |c| Object.send(:remove_const, c) if Object.const_defined?(c) }
+    instance_eval <<EOS
+  module ::Bar
+    def second; 'bar second'; end
+  end
+  
+  module Baz
+    def super_method
+      'super'
+    end
+  end
+  
+  class ::Foo
+    extend Decorator
+    include Bar
+    include Baz
+    module DecorateMe
+      def first; 'first'; end
+      def second; super + ' overridden'; end
+      def third; 'third'; end
+    end
+    include DecorateMe
+  
+    def local
+      'local'
+    end
+  
+    decorate :first, :second, :third, :super_method, :local
+  
+    def third
+      'broken'
+    end
+  end
+  
+  class ::SubFoo < Foo
+    def first
+      'sub ' + super
+    end
+    def first_without_decoration
+      'sub ' + super
+    end
+    def second
+      'sub ' + super
+    end
+    def second_without_decoration
+      'sub ' + super
+    end
+  end
+EOS
+  end
+
+  before(:each) do
+    reload_foo
+  end
+
+  after(:all) do
+    Object.__send__(:remove_const, :Bar)
+    Object.__send__(:remove_const, :Foo)
+  end
+
+  it "should decorate the declared methods" do
+    f = Foo.new
+    f.first.should == "first decorated"
+    f.first_without_decoration.should == "first"
+  end
+
+  it "should decorate superclass methods not declared in DecorateMe" do
+    # the same case as the DecorateMe module
+    f = Foo.new
+    f.super_method.should == "super decorated"
+    f.super_method_without_decoration.should == "super"
+  end
+
+  it "should not interfere with overrides of superclass methods in DecorateMe" do
+    f = Foo.new
+    f.second.should == "bar second overridden decorated"
+    f.second_without_decoration.should == "bar second overridden"
+  end
+
+  it "has the issue that it raises errors attempting to decorate methods defined only in the base class" do
+    f = Foo.new
+    lambda { f.local }.should raise_error(NoMethodError) # not .should == 'local decorated'
+    f.local_without_decoration.should.should == 'local'
+  end
+
+  it "has the issue that overrides in base class override decoration" do
+    f = Foo.new
+    f.third.should == 'broken' # not 'broken decorated'
+    f.third_without_decoration.should == 'third'
+  end
+
+  it "should not interfere with external overrides of superclasses methods" do
+    Bar.class_eval { def second; 'external'; end }
+    f = Foo.new
+    f.second.should == 'external overridden decorated'
+    f.second_without_decoration.should == 'external overridden'
+  end
+
+  it "should allow subclasses to override decoration" do
+    f = SubFoo.new
+    f.first.should == 'sub first decorated'
+    f.second.should == 'sub bar second overridden decorated'
+  end
+
+  it "should allow subclasses to override methods without decoration" do
+    f = SubFoo.new
+    f.first_without_decoration.should == 'sub first'
+    f.second_without_decoration.should == 'sub bar second overridden'
+  end
+
+end
+
+end