require 'abstract_unit' module One Constant1 = "Hello World" Constant2 = "What's up?" end class Ab include One Constant1 = "Hello World" # Will have different object id than One::Constant1 Constant3 = "Goodbye World" end module Xy class Bc include One end end module Yz module Zy class Cd include One end end end class De end Somewhere = Struct.new(:street, :city) Someone = Struct.new(:name, :place) do delegate :street, :city, :to_f, :to => :place delegate :state, :to => :@place delegate :upcase, :to => "place.city" end Invoice = Struct.new(:client) do delegate :street, :city, :name, :to => :client, :prefix => true delegate :street, :city, :name, :to => :client, :prefix => :customer end Project = Struct.new(:description, :person) do delegate :name, :to => :person, :allow_nil => true delegate :to_f, :to => :description, :allow_nil => true end class Name delegate :upcase, :to => :@full_name def initialize(first, last) @full_name = "#{first} #{last}" end end $nowhere = <<-EOF class Name delegate :nowhere end EOF $noplace = <<-EOF class Name delegate :noplace, :tos => :hollywood end EOF class ModuleTest < Test::Unit::TestCase def setup @david = Someone.new("David", Somewhere.new("Paulina", "Chicago")) end def test_included_in_classes assert One.included_in_classes.include?(Ab) assert One.included_in_classes.include?(Xy::Bc) assert One.included_in_classes.include?(Yz::Zy::Cd) assert !One.included_in_classes.include?(De) end def test_delegation_to_methods assert_equal "Paulina", @david.street assert_equal "Chicago", @david.city end def test_delegation_down_hierarchy assert_equal "CHICAGO", @david.upcase end def test_delegation_to_instance_variable david = Name.new("David", "Hansson") assert_equal "DAVID HANSSON", david.upcase end def test_missing_delegation_target assert_raise(ArgumentError) { eval($nowhere) } assert_raise(ArgumentError) { eval($noplace) } end def test_delegation_prefix invoice = Invoice.new(@david) assert_equal invoice.client_name, "David" assert_equal invoice.client_street, "Paulina" assert_equal invoice.client_city, "Chicago" end def test_delegation_custom_prefix invoice = Invoice.new(@david) assert_equal invoice.customer_name, "David" assert_equal invoice.customer_street, "Paulina" assert_equal invoice.customer_city, "Chicago" end def test_delegation_prefix_with_instance_variable assert_raise ArgumentError do Class.new do def initialize(client) @client = client end delegate :name, :address, :to => :@client, :prefix => true end end end def test_delegation_with_allow_nil rails = Project.new("Rails", Someone.new("David")) assert_equal rails.name, "David" end def test_delegation_with_allow_nil_and_nil_value rails = Project.new("Rails") assert_nil rails.name end def test_delegation_with_allow_nil_and_nil_value_and_prefix Project.class_eval do delegate :name, :to => :person, :allow_nil => true, :prefix => true end rails = Project.new("Rails") assert_nil rails.person_name end def test_delegation_without_allow_nil_and_nil_value david = Someone.new("David") assert_raise(RuntimeError) { david.street } end def test_delegation_to_method_that_exists_on_nil nil_person = Someone.new(nil) assert_equal 0.0, nil_person.to_f end def test_delegation_to_method_that_exists_on_nil_when_allowing_nil nil_project = Project.new(nil) assert_equal 0.0, nil_project.to_f end def test_parent assert_equal Yz::Zy, Yz::Zy::Cd.parent assert_equal Yz, Yz::Zy.parent assert_equal Object, Yz.parent end def test_parents assert_equal [Yz::Zy, Yz, Object], Yz::Zy::Cd.parents assert_equal [Yz, Object], Yz::Zy.parents end def test_local_constants assert_equal %w(Constant1 Constant3), Ab.local_constants.sort.map(&:to_s) end def test_as_load_path assert_equal 'yz/zy', Yz::Zy.as_load_path assert_equal 'yz', Yz.as_load_path end end module BarMethodAliaser def self.included(foo_class) foo_class.class_eval do include BarMethods alias_method_chain :bar, :baz end end end module BarMethods def bar_with_baz bar_without_baz << '_with_baz' end def quux_with_baz! quux_without_baz! << '_with_baz' end def quux_with_baz? false end def quux_with_baz=(v) send(:quux_without_baz=, v) << '_with_baz' end def duck_with_orange duck_without_orange << '_with_orange' end end class MethodAliasingTest < Test::Unit::TestCase def setup Object.const_set :FooClassWithBarMethod, Class.new { def bar() 'bar' end } @instance = FooClassWithBarMethod.new end def teardown Object.instance_eval { remove_const :FooClassWithBarMethod } end def test_alias_method_chain assert @instance.respond_to?(:bar) feature_aliases = [:bar_with_baz, :bar_without_baz] feature_aliases.each do |method| assert !@instance.respond_to?(method) end assert_equal 'bar', @instance.bar FooClassWithBarMethod.class_eval { include BarMethodAliaser } feature_aliases.each do |method| assert @instance.respond_to?(method) end assert_equal 'bar_with_baz', @instance.bar assert_equal 'bar', @instance.bar_without_baz end def test_alias_method_chain_with_punctuation_method FooClassWithBarMethod.class_eval do def quux!; 'quux' end end assert !@instance.respond_to?(:quux_with_baz!) FooClassWithBarMethod.class_eval do include BarMethodAliaser alias_method_chain :quux!, :baz end assert @instance.respond_to?(:quux_with_baz!) assert_equal 'quux_with_baz', @instance.quux! assert_equal 'quux', @instance.quux_without_baz! end def test_alias_method_chain_with_same_names_between_predicates_and_bang_methods FooClassWithBarMethod.class_eval do def quux!; 'quux!' end def quux?; true end def quux=(v); 'quux=' end end assert !@instance.respond_to?(:quux_with_baz!) assert !@instance.respond_to?(:quux_with_baz?) assert !@instance.respond_to?(:quux_with_baz=) FooClassWithBarMethod.class_eval { include BarMethodAliaser } assert @instance.respond_to?(:quux_with_baz!) assert @instance.respond_to?(:quux_with_baz?) assert @instance.respond_to?(:quux_with_baz=) FooClassWithBarMethod.alias_method_chain :quux!, :baz assert_equal 'quux!_with_baz', @instance.quux! assert_equal 'quux!', @instance.quux_without_baz! FooClassWithBarMethod.alias_method_chain :quux?, :baz assert_equal false, @instance.quux? assert_equal true, @instance.quux_without_baz? FooClassWithBarMethod.alias_method_chain :quux=, :baz assert_equal 'quux=_with_baz', @instance.send(:quux=, 1234) assert_equal 'quux=', @instance.send(:quux_without_baz=, 1234) end def test_alias_method_chain_with_feature_punctuation FooClassWithBarMethod.class_eval do def quux; 'quux' end def quux?; 'quux?' end include BarMethodAliaser alias_method_chain :quux, :baz! end assert_nothing_raised do assert_equal 'quux_with_baz', @instance.quux_with_baz! end assert_raise(NameError) do FooClassWithBarMethod.alias_method_chain :quux?, :baz! end end def test_alias_method_chain_yields_target_and_punctuation args = nil FooClassWithBarMethod.class_eval do def quux?; end include BarMethods FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation| args = [target, punctuation] end end assert_not_nil args assert_equal 'quux', args[0] assert_equal '?', args[1] end def test_alias_method_chain_preserves_private_method_status FooClassWithBarMethod.class_eval do def duck; 'duck' end include BarMethodAliaser private :duck alias_method_chain :duck, :orange end assert_raise NoMethodError do @instance.duck end assert_equal 'duck_with_orange', @instance.instance_eval { duck } assert FooClassWithBarMethod.private_method_defined?(:duck) end def test_alias_method_chain_preserves_protected_method_status FooClassWithBarMethod.class_eval do def duck; 'duck' end include BarMethodAliaser protected :duck alias_method_chain :duck, :orange end assert_raise NoMethodError do @instance.duck end assert_equal 'duck_with_orange', @instance.instance_eval { duck } assert FooClassWithBarMethod.protected_method_defined?(:duck) end def test_alias_method_chain_preserves_public_method_status FooClassWithBarMethod.class_eval do def duck; 'duck' end include BarMethodAliaser public :duck alias_method_chain :duck, :orange end assert_equal 'duck_with_orange', @instance.duck assert FooClassWithBarMethod.public_method_defined?(:duck) end end