aidmock 0.1.0

data/spec/aidmock/matchers_spec.rb

@@ -0,0 +1,237 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+describe Aidmock::Matchers do
+  m = ::Aidmock::Matchers
+
+  trueMatch = Class.new do
+    def match?(obj)
+      true
+    end
+  end.new
+
+  falseMatch = Class.new do
+    def match?(obj)
+      false
+    end
+  end.new
+
+  context "create matcher by value" do
+    it "use the matcher if one is sent" do
+      m.create(trueMatch).should == trueMatch
+    end
+
+    it "use an AnyMatcher if an array is sent" do
+      m.create([trueMatch, falseMatch]).should be_an_instance_of(m::AnyMatcher)
+    end
+
+    it "use KindOfMatcher if a class is sent" do
+      m.create(String).should be_an_instance_of(m::KindOfMatcher)
+    end
+
+    it "use AnythingMatcher if nil is sent" do
+      m.create(nil).should be_an_instance_of(m::AnythingMatcher)
+    end
+
+    it "use DuckTypeMatcher if receive a symbol" do
+      m.create(:to_s).should be_an_instance_of(m::DuckTypeMatcher)
+    end
+
+    it "use HashMatcher if receive a hash" do
+      m.create(:name => nil).should be_an_instance_of(m::HashMatcher)
+    end
+
+    it "raise error if can't figure a matcher" do
+      expect { m.create("") }.to raise_error
+    end
+  end
+
+  context "matchers" do
+    context "AnyMatcher" do
+      it "pass if any of matchers matches" do
+        matcher = m::AnyMatcher.new(falseMatch, trueMatch)
+        matcher.should matches("obj")
+      end
+
+      it "fails if no matcher can match" do
+        matcher = m::AnyMatcher.new(falseMatch, falseMatch)
+        matcher.should_not matches("obj")
+      end
+    end
+
+    context "AnythingMatcher" do
+      it "always pass" do
+        matcher = m::AnythingMatcher.new
+        matcher.should matches("something")
+      end
+
+      it "should pass with nil" do
+        matcher = m::AnythingMatcher.new
+        matcher.should matches(nil)
+      end
+    end
+
+    context "DuckTypeMatcher" do
+      it "pass if object respond to all methods" do
+        matcher = m::DuckTypeMatcher.new(:to_s, :gsub)
+        matcher.should matches("string")
+      end
+
+      it "pass if object is nil" do
+        matcher = m::DuckTypeMatcher.new(:to_s, :gsub)
+        matcher.should matches(nil)
+      end
+
+      it "fail if object don't respond to any of methods" do
+        matcher = m::DuckTypeMatcher.new(:to_s, :gsub, :i_fail_things)
+        matcher.should_not matches("string")
+      end
+    end
+
+    context "InstanceOfMatcher" do
+      it "pass if the object is an instance of given" do
+        matcher = m::InstanceOfMatcher.new(String)
+        matcher.should matches("string")
+      end
+
+      it "pass if the object is nil" do
+        matcher = m::InstanceOfMatcher.new(String)
+        matcher.should matches(nil)
+      end
+
+      it "fail if object is not an instance of given" do
+        matcher = m::InstanceOfMatcher.new(Numeric)
+        matcher.should_not matches(4)
+      end
+    end
+
+    context "KindOfMatcher" do
+      it "pass if the object is an instance of given" do
+        matcher = m::KindOfMatcher.new(String)
+        matcher.should matches("string")
+      end
+
+      it "pass if the object is an kind of given" do
+        matcher = m::KindOfMatcher.new(Numeric)
+        matcher.should matches(4)
+      end
+
+      it "pass if the object is nil" do
+        matcher = m::KindOfMatcher.new(String)
+        matcher.should matches(nil)
+      end
+
+      it "fail if object is not an instance of given" do
+        matcher = m::KindOfMatcher.new(String)
+        matcher.should_not matches(4)
+      end
+    end
+
+    context "HashMatcher" do
+      context "flexible mode" do
+        it "pass if hash contains only valid keys" do
+          matcher = m::HashMatcher.new(:name => trueMatch, :email => falseMatch)
+          matcher.should matches(:name => "hi")
+        end
+
+        it "pass if the object is nil" do
+          matcher = m::HashMatcher.new(:name => trueMatch, :email => falseMatch)
+          matcher.should matches(nil)
+        end
+
+        it "fails if send an invalid key to hash" do
+          matcher = m::HashMatcher.new(:name => trueMatch, :email => trueMatch)
+          matcher.should_not matches(:other => "hi")
+        end
+
+        it "fails if send a valid key with invalid value" do
+          matcher = m::HashMatcher.new(:name => falseMatch, :email => trueMatch)
+          matcher.should_not matches(:name => "bar")
+        end
+      end
+
+      context "strict mode" do
+        it "pass if hash contains all valid keys" do
+          matcher = m::HashMatcher.new({:name => trueMatch, :email => trueMatch}, true)
+          matcher.should matches(:name => "hi", :email => "ho")
+        end
+
+        it "fails if any key is missing" do
+          matcher = m::HashMatcher.new({:name => trueMatch, :email => trueMatch}, true)
+          matcher.should_not matches(:name => "hi")
+        end
+
+        it "fails if has extra keys" do
+          matcher = m::HashMatcher.new({:name => trueMatch, :email => trueMatch}, true)
+          matcher.should_not matches(:name => "hi", :email => "ho", :other => "hu")
+        end
+      end
+    end
+
+    context "NotNilArgMatcher" do
+      it "pass if internal matcher pass" do
+        matcher = m::NotNilArgMatcher.new(trueMatch)
+        matcher.should matches("hi")
+      end
+
+      it "fails if internal matcher fails" do
+        matcher = m::NotNilArgMatcher.new(falseMatch)
+        matcher.should_not matches("hi")
+      end
+
+      it "fails if object is nil" do
+        matcher = m::NotNilArgMatcher.new(trueMatch)
+        matcher.should_not matches(nil)
+      end
+    end
+
+    context "OptionalArgMatcher" do
+      it "just call match at given matcher" do
+        matcher = m::OptionalArgMatcher.new(trueMatch)
+        matcher.should matches("thing")
+      end
+    end
+
+    context "SplatArgMatcher" do
+      it "use anything matcher by default" do
+        matcher = m::SplatArgMatcher.new
+        matcher.should matches([true])
+      end
+
+      it "should try to match every given value at splat" do
+        matcher = m::SplatArgMatcher.new(trueMatch)
+        trueMatch.should_receive(:match?).with(1) { true }
+        trueMatch.should_receive(:match?).with(2) { true }
+        trueMatch.should_receive(:match?).with(3) { true }
+
+        matcher.should matches([1, 2, 3])
+      end
+
+      it "fail if any of args don't respect matcher" do
+        matcher = m::SplatArgMatcher.new(trueMatch)
+        trueMatch.stub(:match?).with(1) { true }
+        trueMatch.stub(:match?).with(2) { false }
+        trueMatch.stub(:match?).with(3) { true }
+
+        matcher.should_not matches([1, 2, 3])
+      end
+    end
+  end
+end

data/spec/aidmock/method_descriptor_spec.rb

@@ -0,0 +1,205 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+describe Aidmock::MethodDescriptor do
+  mock_descriptor = Aidmock::Frameworks::MockDescriptor
+  md = Aidmock::MethodDescriptor
+  m = Aidmock::Matchers
+
+  trueMatch = Class.new do
+    def match?(obj)
+      true
+    end
+  end.new
+
+  falseMatch = Class.new do
+    def match?(obj)
+      false
+    end
+  end.new
+
+  def mock_return(val)
+    Aidmock::Frameworks::MockDescriptor.new(nil, :some, val)
+  end
+
+  def mock_args(args)
+    Aidmock::Frameworks::MockDescriptor.new(nil, :some, nil, args)
+  end
+
+  it "verify the arguments and return value" do
+    double = mock_descriptor.new(nil, :method, :result, [:args])
+    desc = md.new(:some, nil)
+    desc.should_receive(:verify_arguments).with(double)
+    desc.should_receive(:verify_return).with(double)
+    desc.verify(double)
+  end
+
+  context "verifying return value" do
+    it "raise error if return value don't match" do
+      desc = md.new(:some, falseMatch)
+
+      expect { desc.verify_return(mock_return([nil])) }.to raise_error(Aidmock::MethodInterfaceReturnNotMatchError)
+    end
+
+    it "not raise error if return value match" do
+      desc = md.new(:some, trueMatch)
+
+      expect { desc.verify_return(mock_return([nil])) }.to_not raise_error
+    end
+
+    it "send double value to matcher" do
+      desc = md.new(:some, trueMatch)
+      trueMatch.should_receive(:match?).with("hi").and_return(true)
+      trueMatch.should_receive(:match?).with("ho").and_return(true)
+
+      desc.verify_return(mock_return(["hi", "ho"]))
+    end
+  end
+
+  context "verifying arguments" do
+    context "testing arguments arity" do
+      context "on fixed arguments length" do
+        it "raise error if user send less arguments than method expects" do
+          desc = md.new(:some, nil, trueMatch, trueMatch)
+
+          expect { desc.verify_arguments(mock_args([5]))}.to raise_error(Aidmock::MethodInterfaceArgumentsNotMatchError, "error on mock method :some, expected 2 arguments, 1 sent")
+        end
+
+        it "raise error if user send more arguments than method expects" do
+          desc = md.new(:some, nil, trueMatch, trueMatch)
+
+          expect { desc.verify_arguments(mock_args([5, 6, 7]))}.to raise_error(Aidmock::MethodInterfaceArgumentsNotMatchError, "error on mock method :some, expected 2 arguments, 3 sent")
+        end
+
+        it "not raise error if they are in correct arity" do
+          desc = md.new(:some, nil, trueMatch, trueMatch)
+
+          expect { desc.verify_arguments(mock_args([5, 6]))}.to_not raise_error
+        end
+      end
+
+      context "on variable arguments length" do
+        it "raise error if number of arguments is less than required ones" do
+          desc = md.new(:some, nil, trueMatch, Aidmock::Matchers::OptionalArgMatcher.new(trueMatch))
+
+          expect { desc.verify_arguments(mock_args([])) }.to raise_error(Aidmock::MethodInterfaceArgumentsNotMatchError, "error on mock method :some, expected at least 1, 0 sent")
+        end
+
+        it "raise error if it has more args than possible (after optional ones)" do
+          desc = md.new(:some, nil, trueMatch, Aidmock::Matchers::OptionalArgMatcher.new(trueMatch))
+
+          expect { desc.verify_arguments(mock_args([1, 2, 3])) }.to raise_error(Aidmock::MethodInterfaceArgumentsNotMatchError, "error on mock method :some, expected at most 2, 3 sent")
+        end
+
+        it "dont raise error if fits on argument length" do
+          desc = md.new(:some, nil, trueMatch, Aidmock::Matchers::OptionalArgMatcher.new(trueMatch))
+
+          expect { desc.verify_arguments(mock_args([1])) }.to_not raise_error
+          expect { desc.verify_arguments(mock_args([1, 2])) }.to_not raise_error
+        end
+
+        it "dont raise error if has more arguments than max, but has a splat" do
+          desc = md.new(:some, nil, trueMatch, Aidmock::Matchers::SplatArgMatcher.new(trueMatch))
+
+          expect { desc.verify_arguments(mock_args([1, 2, 3])) }.to_not raise_error
+        end
+      end
+    end
+
+    context "checking arguments" do
+      it "try each argument on respective matcher" do
+        m1 = mock
+        m2 = mock
+
+        m1.should_receive(:match?).with(1).and_return(true)
+        m2.should_receive(:match?).with(2).and_return(true)
+
+        desc = md.new(:some, nil, m1, m2)
+        desc.verify_arguments(mock_args([1, 2]))
+      end
+
+      it "raise error if any matcher fail" do
+        desc = md.new(:some, nil, falseMatch, trueMatch)
+
+        expect { desc.verify_arguments(mock_args([1, 2])) }.to raise_error(Aidmock::MethodInterfaceArgumentsNotMatchError)
+      end
+
+      it "send an array with others if has a splat" do
+        matcher = mock
+        matcher.should_receive(:match?).with(2).and_return(true)
+        matcher.should_receive(:match?).with(3).and_return(true)
+
+        desc = md.new(:some, nil, trueMatch, Aidmock::Matchers::SplatArgMatcher.new(matcher))
+        desc.verify_arguments(mock_args([1, 2, 3]))
+      end
+    end
+  end
+
+  context "#arity" do
+    it "return 0 if no arguments are given" do
+      md.new(:some, nil).arity.should == 0
+    end
+
+    it "return positive number of arguments if they are regular ones" do
+      md.new(:some, nil, nil, nil).arity.should == 2
+    end
+
+    it "return -1 if start with optional argument" do
+      md.new(:some, nil, m::OptionalArgMatcher.new(nil)).arity.should == -1
+    end
+
+    it "return -1 if start with splat argument" do
+      md.new(:some, nil, m::SplatArgMatcher.new(nil)).arity.should == -1
+    end
+
+    it "return negative value when has both optional and required args" do
+      md.new(:some, nil, nil, m::OptionalArgMatcher.new(nil)).arity.should == -2
+    end
+
+    it "return negative value when has both splt and required args" do
+      md.new(:some, nil, nil, m::SplatArgMatcher.new(nil)).arity.should == -2
+    end
+
+    it "return negative when have optional, required and splt args" do
+      md.new(:some, nil, nil, m::OptionalArgMatcher.new(nil), m::SplatArgMatcher.new(nil)).arity.should == -2
+    end
+  end
+
+  context "#required_arity" do
+    before :each do
+      @m = md.new(:some, nil)
+    end
+
+    it "return arity if its positive" do
+      @m.stub(:arity).and_return(1)
+      @m.required_arity.should == 1
+    end
+
+    it "return 0 if arity is 0" do
+      @m.stub(:arity).and_return(0)
+      @m.required_arity.should == 0
+    end
+
+    it "return arity positive less 1 if it's negative" do
+      @m.stub(:arity).and_return(-2)
+      @m.required_arity.should == 1
+    end
+  end
+end

data/spec/aidmock/sanity_spec.rb

@@ -0,0 +1,119 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+describe Aidmock::Sanity do
+  context ".sanitize_interfaces" do
+    it "check each defined interface" do
+      m1 = mock
+      m2 = mock
+
+      Aidmock.stub!(:interfaces).and_return({:a => m1, :b => m2})
+      Aidmock::Sanity.should_receive(:sanitize_interface).with(m1)
+      Aidmock::Sanity.should_receive(:sanitize_interface).with(m2)
+
+      Aidmock::Sanity.sanitize_interfaces
+    end
+  end
+
+  context ".sanitize_interface" do
+    it "check each method defined on interface" do
+      m1 = mock
+      m2 = mock
+      m3 = mock
+      m4 = mock
+      ca = mock
+
+      interface = Aidmock::Interface.allocate
+      interface.stub(:methods).and_return([m1, m2])
+      interface.stub(:class_methods).and_return([m3, m4])
+      interface.stub(:klass).and_return(ca)
+
+      Aidmock::Sanity.should_receive(:sanitize_method).with(ca, m1)
+      Aidmock::Sanity.should_receive(:sanitize_method).with(ca, m2)
+      Aidmock::Sanity.should_receive(:sanitize_method).with(ca, m3)
+      Aidmock::Sanity.should_receive(:sanitize_method).with(ca, m4)
+
+      Aidmock::Sanity.sanitize_interface(interface)
+    end
+  end
+
+  context ".sanitize_method" do
+    before :each do
+      @ca = mock(:allocate => Object)
+      @me = mock(:name => :to_s, :arity => 0, :class_method? => false)
+    end
+
+    it "verify if method is defined" do
+      Aidmock::Sanity.should_receive(:verify_method_defined).with(@ca, @me)
+      Aidmock::Sanity.sanitize_method(@ca, @me)
+    end
+
+    it "verify if method arity" do
+      Aidmock::Sanity.should_receive(:verify_method_arity).with(@ca, @me)
+      Aidmock::Sanity.sanitize_method(@ca, @me)
+    end
+  end
+
+  context ".verify_method_defined" do
+    it "raise error if object don't have the method defined" do
+      klass = Object
+      method = Aidmock::MethodDescriptor.new(:foo_isnt_here, nil)
+
+      expect { Aidmock::Sanity.verify_method_defined(klass, method) }.to raise_error("Aidmock Sanity: method 'foo_isnt_here' is not defined for Object")
+    end
+
+    it "don't raise error if object has the method" do
+      klass = Object
+      method = Aidmock::MethodDescriptor.new(:to_s, nil)
+
+      expect { Aidmock::Sanity.verify_method_defined(klass, method) }.to_not raise_error
+    end
+
+    it "don't check for regexp methods" do
+      klass = String
+      method = Aidmock::MethodDescriptor.new(/concat_.*/, nil, [String, Fixnum])
+
+      expect { Aidmock::Sanity.verify_method_arity(klass, method) }.to_not raise_error
+    end
+  end
+
+  context ".verify_method_arity" do
+    it "raise error if arity is different" do
+      klass = String
+      method = Aidmock::MethodDescriptor.new(:gsub, nil)
+
+      expect { Aidmock::Sanity.verify_method_arity(klass, method) }.to raise_error("Aidmock Sanity: method 'gsub' of String mismatch interface arity, -1 for 0")
+    end
+
+    it "not raise error if arity is same" do
+      klass = String
+      method = Aidmock::MethodDescriptor.new(:concat, nil, [String, Fixnum])
+
+      expect { Aidmock::Sanity.verify_method_arity(klass, method) }.to_not raise_error
+    end
+
+    it "don't check for regexp methods" do
+      klass = String
+      method = Aidmock::MethodDescriptor.new(/concat_.*/, nil, [String, Fixnum])
+
+      expect { Aidmock::Sanity.verify_method_arity(klass, method) }.to_not raise_error
+    end
+  end
+end

data/spec/aidmock_spec.rb

@@ -0,0 +1,124 @@
+# Copyright (c) 2011 Wilker Lúcio
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+describe Aidmock do
+  context ".interface" do
+  end
+
+  context ".stub" do
+  end
+
+  context ".verify" do
+    it "do verify double on each double returned by framework" do
+      m1 = mock; m2 = mock; m3 = mock
+      framework = stub(:mocks => [m1, m2, m3])
+      Aidmock.stub!(:framework) { framework }
+
+      Aidmock.should_receive(:verify_double).with(m1) { nil }
+      Aidmock.should_receive(:verify_double).with(m2) { nil }
+      Aidmock.should_receive(:verify_double).with(m3) { nil }
+
+      Aidmock.verify
+    end
+  end
+
+  context ".verify_double" do
+    it "call to verify chain if the chain has any element" do
+      double = Aidmock::Frameworks::MockDescriptor.new("object", :to_s, nil, [])
+
+      Aidmock.stub!(:chain_for).with(String) { [String] }
+      Aidmock.should_receive(:verify_double_on_chain).with(double, [String])
+
+      Aidmock.send :verify_double, double
+    end
+  end
+
+  context ".verify_double_on_chain" do
+    it "call verify on method descriptor if method exists" do
+      double = mock
+      chain = mock
+      method = mock
+      method.should_receive(:verify).with(double)
+
+      Aidmock.stub!(:find_method_on_chain).with(double, chain).and_return(method)
+
+      Aidmock.send(:verify_double_on_chain, double, chain)
+    end
+
+    it "raise error if method can't be found" do
+      double = stub(:method => nil, :object => nil)
+      chain = mock
+
+      Aidmock.stub!(:find_method_on_chain).with(double, chain).and_return(nil)
+
+      expect { Aidmock.send(:verify_double_on_chain, double, chain) }.to raise_error(Aidmock::MethodInterfaceNotDefinedError)
+    end
+  end
+
+  context ".find_method_on_chain" do
+    it "get method if the interface has it" do
+      double = stub(:method => :some)
+      interface = stub
+      interface.stub(:find_method).with(double).and_return(true)
+
+      Aidmock.send(:find_method_on_chain, double, [interface]).should == true
+    end
+
+    it "return nil if no interface has the method" do
+      double = stub(:method => :some)
+      interface = stub
+      interface.stub(:find_method).with(double) { nil }
+
+      Aidmock.send(:find_method_on_chain, double, [interface]).should == nil
+    end
+
+    it "use first occurence if more than one on chain can respond to method" do
+      m1 = mock, m2 = mock
+      double = stub(:method => :some)
+      interface = stub
+      interface.stub(:find_method).with(double) { nil }
+      interface2 = stub
+      interface2.stub(:find_method).with(double) { m1 }
+      interface3 = stub
+      interface3.stub(:find_method).with(double) { m2 }
+
+      Aidmock.send(:find_method_on_chain, double, [interface, interface2, interface3]).should == m1
+    end
+  end
+
+  context ".class_chain" do
+    it "get chain of defined interfaces on a class" do
+      m1 = mock
+      m2 = mock
+      Aidmock.stub!(:interfaces).and_return({String => m1, Object => m2, Fixnum => true})
+      Aidmock.send(:chain_for, String).should == [m1, m2]
+    end
+  end
+
+  context ".extract_class" do
+    it "return the object class if it's an instance" do
+      Aidmock.send(:extract_class, "string").should == String
+    end
+
+    it "return the object if it's an class" do
+      Aidmock.send(:extract_class, String).should == String
+    end
+  end
+end