aquarium 0.1.8 → 0.2.0

data/spec/aquarium/extras/design_by_contract_spec.rb

@@ -7,7 +7,7 @@ describe Aquarium::Extras::DesignByContract, "precondition" do
     def action *args
     end
     
-    precondition :method => :action, :message => "Must pass more than one argument." do |jp, *args|
+    precondition :method => :action, :message => "Must pass more than one argument." do |jp, obj, *args|
       args.size > 0
     end
   end
@@ -27,7 +27,7 @@ describe Aquarium::Extras::DesignByContract, "postcondition" do
     def action *args
     end
     
-    postcondition :method => :action, :message => "Must pass more than one argument and first argument must be non-empty." do |jp, *args|
+    postcondition :method => :action, :message => "Must pass more than one argument and first argument must be non-empty." do |jp, obj, *args|
       args.size > 0 && ! args[0].empty?
     end
   end
@@ -58,8 +58,8 @@ describe Aquarium::Extras::DesignByContract, "invariant" do
       "bad"
     end
     
-    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, *args|
-      jp.context.advised_object.invar == 0
+    invariant :methods => /action$/, :message => "Must not change the @invar value." do |jp, obj, *args|
+      obj.invar == 0
     end
   end
   

data/spec/aquarium/finders/method_finder_spec.rb

@@ -15,6 +15,18 @@ module M
   end
   def mmodule2
   end
+  def self.cmmodule1
+  end
+end
+
+module M2
+  include M
+  def mmodule3
+  end
+  def mmodule4
+  end
+  def self.cmmodule3
+  end
 end
 
 class Derived < Base
@@ -25,8 +37,24 @@ class Derived < Base
   end
   def mmodule1
   end
+  def mmodule2b
+  end
+end
+
+class Derived2 < Base
+  include M2
+  def mbase1
+  end
+  def mderived1
+  end
+  def mmodule1
+  end
+  def mmodule2b
+  end
   def mmodule3
   end
+  def mmodule4b
+  end
 end
 
 # :startdoc:
@@ -203,30 +231,75 @@ describe Aquarium::Finders::MethodFinder, "#find (behavior for derived classes)"
     before_method_finder_spec
   end
     
-  it "should find Base and Derived methods in the specified class, by default." do
+  it "should find base and derived methods in the specified class, by default." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mbase/, /^mmodule/]
     actual.matched.size.should == 1
-    actual.matched[Derived].should == Set.new([:mbase1, :mbase2, :mmodule1, :mmodule2, :mmodule3])
+    actual.matched[Derived].should == Set.new([:mbase1, :mbase2, :mmodule1, :mmodule2, :mmodule2b])
   end
    
-  it "should find Base and Derived methods in the specified object, by default." do
+  it "should find base and derived methods in the specified object, by default." do
     child = Derived.new
     actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mbase/, /^mderived/, /^mmodule/]
     actual.matched.size.should == 1
-    actual.matched[child].should == Set.new([:mbase1, :mbase2, :mderived1, :mmodule1, :mmodule2, :mmodule3])
+    actual.matched[child].should == Set.new([:mbase1, :mbase2, :mderived1, :mmodule1, :mmodule2, :mmodule2b])
   end
    
-  it "should find Derived methods only for a type when ancestor methods are suppressed, which also suppresses method overrides." do
+  it "should only find Derived methods for a type when ancestor methods are excluded, which also excludes method overrides." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => [/^mder/, /^mmod/], :options => [:exclude_ancestor_methods]
     actual.matched.size.should == 1
-    actual.matched[Derived].should == Set.new([:mderived1, :mmodule3])
+    actual.matched[Derived].should == Set.new([:mderived1, :mmodule2b])
   end
 
-  it "should find Derived methods only for an object when ancestor methods are suppressed, which also suppresses method overrides." do
+  it "should only find Derived methods for an object when ancestor methods are excluded, which also excludes method overrides." do
     child = Derived.new
     actual = Aquarium::Finders::MethodFinder.new.find :object => child, :methods => [/^mder/, /^mmodule/], :options => [:exclude_ancestor_methods]
     actual.matched.size.should == 1
-    actual.matched[child].should == Set.new([:mderived1, :mmodule3])
+    actual.matched[child].should == Set.new([:mderived1, :mmodule2b])
+  end
+end
+  
+describe Aquarium::Finders::MethodFinder, "#find (behavior for included modules)" do
+  before(:each) do
+    before_method_finder_spec
+  end
+    
+  it "should find included and defined methods in the specified modules, by default." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => [M, M2], :methods => /^mmodule/
+    actual.matched.size.should == 2
+    actual.matched[M].should  == Set.new([:mmodule1, :mmodule2])
+    actual.matched[M2].should == Set.new([:mmodule1, :mmodule2, :mmodule3, :mmodule4])
+  end
+   
+  it "should find included and overridden methods in classes that include the specified modules, by default." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [Derived, Derived2], :methods => /^mmodule/
+    actual.matched.size.should == 2
+    actual.matched[Derived].should  == Set.new([:mmodule1, :mmodule2, :mmodule2b])
+    actual.matched[Derived2].should == Set.new([:mmodule1, :mmodule2, :mmodule2b, :mmodule3, :mmodule4, :mmodule4b])
+  end
+   
+  it "should find included and overridden methods in instances of classes that include the specified modules, by default." do
+    child  = Derived.new
+    child2 = Derived2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [child, child2], :methods => /^mmodule/
+    actual.matched.size.should == 2
+    actual.matched[child].should  == Set.new([:mmodule1, :mmodule2, :mmodule2b])
+    actual.matched[child2].should == Set.new([:mmodule1, :mmodule2, :mmodule2b, :mmodule3, :mmodule4, :mmodule4b])
+  end
+   
+  it "should only find defined methods for a module when ancestor methods are excluded, which also excludes method overrides." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => [M, M2], :methods => /^mmod/, :options => [:exclude_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[M].should  == Set.new([:mmodule1, :mmodule2])
+    actual.matched[M2].should == Set.new([:mmodule3, :mmodule4])
+  end
+
+  it "should not find any methods from included modules in classes when ancestor methods are excluded, which also excludes method overrides." do
+    child  = Derived.new
+    child2 = Derived2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [child, child2], :methods => /^mmodule/, :options => [:exclude_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[child].should  == Set.new([:mmodule2b])
+    actual.matched[child2].should == Set.new([:mmodule2b, :mmodule4b])
   end
 end
   
@@ -235,7 +308,7 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
     before_method_finder_spec
   end
   
-  it "should find all class methods matching a regular expression for types when :class is used." do
+  it "should find all class methods specified by regular expression for types when :class is used." do
     # Have to add some rspec methods to the expected lists!
     expected = {}
     expected[Kernel] = [:chomp!, :chop!, :respond_to?]
@@ -266,12 +339,60 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for class methods)"
   end
 end
   
+describe Aquarium::Finders::MethodFinder, "#find (searching for class methods defined in modules)" do
+  before(:each) do
+    before_method_finder_spec
+  end
+
+  def do_class_methods_for_modules method_spec, options_spec
+    actual = Aquarium::Finders::MethodFinder.new.find :type => [M, M2], :methods => method_spec, :options => options_spec
+    actual.matched.size.should == 2
+    actual.matched[M].should  == Set.new([:cmmodule1])
+    actual.matched[M2].should == Set.new([:cmmodule3])
+  end
+  
+  it "should find all class methods specified by regular expression for modules when :class is used." do
+    do_class_methods_for_modules /^cmmodule/, [:class]
+  end
+  
+  it "should find all class methods specified by name for modules when :class is used." do
+    do_class_methods_for_modules [:cmmodule1, :cmmodule3], [:class]
+  end
+  
+  it "should not find class methods defined in included modules, because they do not become class methods in the including module." do
+    do_class_methods_for_modules /^cmmodule/, [:class]
+  end
+  
+  it "should not find class methods defined in included modules, if ancestor methods are excluded explicitly." do
+    do_class_methods_for_modules /^cmmodule/, [:class, :exclude_ancestor_methods]
+  end
+  
+  it "should find all public class methods in types when searching with the :all method specification and the :class option." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => [M, M2], :methods => :all, :options => [:class]
+    actual.matched.size.should == 2
+    actual.matched[M].should  == Set.new(M.public_methods.sort.map{|m| m.intern})
+    actual.matched[M2].should == Set.new(M2.public_methods.sort.map{|m| m.intern})
+  end
+  
+  it "should not find any module-defined class methods in classes that include the modules." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [Derived, Derived2], :methods => /^cmmodule/, :options => [:class]
+    actual.matched.size.should == 0
+  end
+   
+  it "should not find any module-defined class methods in instances of classes that include the modules." do
+    child  = Derived.new
+    child2 = Derived2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :objects => [child, child2], :methods => /^cmmodule/, :options => [:class]
+    actual.matched.size.should == 0
+  end
+end
+
 describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods)" do
   before(:each) do
     before_method_finder_spec
   end
   
-  it "should find all public instance methods in types when searching with the :all method specification." do
+  it "should find all public instance methods in classes when searching with the :all method specification." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod], :methods => :all
     actual.matched.size.should == 3
     [ClassWithPublicInstanceMethod, ClassWithProtectedInstanceMethod, ClassWithPrivateInstanceMethod].each do |c|
@@ -279,6 +400,13 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods
     end
   end
   
+  it "should find all public instance methods in modules when searching with the :all method specification." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [M, M2], :methods => :all
+    actual.matched.size.should == 2
+    actual.matched[M].should  == Set.new([:mmodule1, :mmodule2])
+    actual.matched[M2].should == Set.new([:mmodule1, :mmodule2, :mmodule3, :mmodule4])
+  end
+  
   it "should find all public instance methods in objects when searching with the :all method specification." do
     pub = ClassWithPublicInstanceMethod.new
     pro = ClassWithProtectedInstanceMethod.new
@@ -290,6 +418,22 @@ describe Aquarium::Finders::MethodFinder, "#find (searching for instance methods
     end
   end
   
+  it "should find the module-defined public instance methods in when searching a class with the :all method specification." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [Derived, Derived2], :methods => :all
+    actual.matched.size.should == 2
+    [:mmodule1, :mmodule2].each {|m| actual.matched[Derived].should include(m)}
+    [:mmodule1, :mmodule2, :mmodule3, :mmodule4].each {|m| actual.matched[Derived2].should include(m)}
+  end
+  
+  it "should find the module-defined public instance methods in when searching an instance of a class with the :all method specification." do
+    child  = Derived.new
+    child2 = Derived2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [child, child2], :methods => :all
+    actual.matched.size.should == 2
+    [:mmodule1, :mmodule2].each {|m| actual.matched[child].should include(m)}
+    [:mmodule1, :mmodule2, :mmodule3, :mmodule4].each {|m| actual.matched[child2].should include(m)}
+  end
+  
   it "should find only one instance method for a type when searching with a regexp matching one method." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPublicInstanceMethod, :methods => /instance_test_method/
     actual.matched.size.should == 1
@@ -443,19 +587,41 @@ class ExcludeMethodTester
 end
   
 describe Aquarium::Finders::MethodFinder, "#find for types (using :exclude_methods)" do
-  it "should return an empty result if :exclude_methods => :all specified." do
+  it "should return an empty result for classes if :exclude_methods => :all specified." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 0
     actual.not_matched.size.should == 0
   end
+  it "should return an empty result for modules if :exclude_methods => :all specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => M2, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 0
+  end
+  it "should return an empty result for classes including modules if :exclude_methods => :all specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived2, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 0
+  end
   
-  it "should remove excluded methods from the result where a single excluded methods is specified by name." do
+  it "should remove excluded methods from the result for classes where a single excluded methods is specified by name." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_method => :method1, :options => :exclude_ancestor_methods
     actual.matched.size.should == 1
     actual.matched[ExcludeMethodTester].size.should == 2
     actual.matched[ExcludeMethodTester].should == Set.new([:method2, :method3])
     actual.not_matched.size.should == 0
   end
+  it "should remove excluded methods from the result for modules where a single excluded methods is specified by name." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => M, :methods => :all, :exclude_method => :mmodule1
+    actual.matched.size.should == 1
+    actual.matched[M].size.should == 1
+    actual.matched[M].should == Set.new([:mmodule2])
+    actual.not_matched.size.should == 0
+  end
+  it "should remove excluded methods from the result for classes that include modules where a single excluded methods is specified by name." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => Derived, :methods => :all, :exclude_method => :mmodule1
+    actual.matched.size.should == 1
+    actual.matched[Derived].should_not include(:mmodule1)
+  end
   
   it "should remove excluded methods from the result where the excluded methods are specified by an array of names." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => ExcludeMethodTester, :methods => :all, :exclude_methods => [:method1, :method2], :options => :exclude_ancestor_methods
@@ -488,11 +654,16 @@ describe Aquarium::Finders::MethodFinder, "#find for types (using :exclude_metho
 end
   
 describe Aquarium::Finders::MethodFinder, "#find for objects (using :exclude_methods)" do
-  it "should return an empty result if :exclude_methods => :all specified." do
+  it "should return an empty result for instances of classes if :exclude_methods => :all specified." do
     actual = Aquarium::Finders::MethodFinder.new.find :object => ExcludeMethodTester.new, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
     actual.matched.size.should == 0
     actual.not_matched.size.should == 0
   end
+  it "should return an empty result for for instances of classes that include modules if :exclude_methods => :all specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :object => Derived2.new, :methods => :all, :exclude_methods => :all, :options => :exclude_ancestor_methods
+    actual.matched.size.should == 0
+    actual.not_matched.size.should == 0
+  end
   
   it "should remove excluded methods from the result where a single excluded methods is specified by name." do
     emt = ExcludeMethodTester.new
@@ -542,7 +713,7 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => :exclude_anc
     before_method_finder_spec
   end
   
-  it "should suppress ancestor methods for types when :exclude_ancestor_methods is specified." do
+  it "should suppress ancestor methods for classes when :exclude_ancestor_methods is specified." do
     actual = Aquarium::Finders::MethodFinder.new.find :types => @test_classes, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
     actual.matched[ClassWithPublicInstanceMethod].should    == Set.new([:public_instance_test_method])
@@ -552,7 +723,6 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => :exclude_anc
     actual.not_matched[ClassWithPublicClassMethod].should       == Set.new([/test_method/])
     actual.not_matched[ClassWithPrivateClassMethod].should      == Set.new([/test_method/])
   end
-
   it "should suppress ancestor methods for objects when :exclude_ancestor_methods is specified." do
     actual = Aquarium::Finders::MethodFinder.new.find :objects => @test_objects, :methods => /test_method/, :options => [:public, :instance, :exclude_ancestor_methods]
     actual.matched.size.should == 1
@@ -563,6 +733,29 @@ describe Aquarium::Finders::MethodFinder, "#find (using :options => :exclude_anc
     actual.not_matched[@cpub].should == Set.new([/test_method/])
     actual.not_matched[@cpri].should == Set.new([/test_method/])
   end
+
+  it "should suppress ancestor methods for modules when :exclude_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :type => M2, :methods => /^mmodule/, :options => [:instance, :exclude_ancestor_methods]
+    actual.matched.size.should == 1
+    actual.matched[M2].should == Set.new([:mmodule3, :mmodule4])
+    actual.not_matched.size.should == 0
+  end
+  it "should suppress ancestor methods for classes including modules when :exclude_ancestor_methods is specified." do
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [Derived, Derived2], :methods => /^mmodule/, :options => [:instance, :exclude_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[Derived].should  == Set.new([:mmodule2b])
+    actual.matched[Derived2].should == Set.new([:mmodule2b, :mmodule4b])
+    actual.not_matched.size.should == 0
+  end
+  it "should suppress ancestor methods for instances of classes including modules when :exclude_ancestor_methods is specified." do
+    child  = Derived.new
+    child2 = Derived2.new
+    actual = Aquarium::Finders::MethodFinder.new.find :types => [child, child2], :methods => /^mmodule/, :options => [:instance, :exclude_ancestor_methods]
+    actual.matched.size.should == 2
+    actual.matched[child].should  == Set.new([:mmodule2b])
+    actual.matched[child2].should == Set.new([:mmodule2b, :mmodule4b])
+    actual.not_matched.size.should == 0
+  end
 end
   
 describe Aquarium::Finders::MethodFinder, "#find (using :options => [:public, :instance])" do
@@ -925,45 +1118,6 @@ describe "Aquarium::Finders::MethodFinder#find (looking for methods that end in
   end  
 end
 
-describe "Aquarium::Finders::MethodFinder#find_all_by" do
-  it "should accept :all for the methods argument." do
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPublicInstanceMethod, :all, :exclude_ancestor_methods
-    actual.matched.size.should == 1
-    actual.matched[ClassWithPublicInstanceMethod].should == Set.new([:public_instance_test_method])
-    actual.not_matched.size.should == 0
-    pub = ClassWithPublicInstanceMethod.new
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by pub, :all, :exclude_ancestor_methods
-    actual.matched.size.should == 1
-    actual.matched[pub].should == Set.new([:public_instance_test_method])
-    actual.not_matched.size.should == 0
-  end
-  
-  it "should behave like Aquarium::Finders::MethodFinder#find with an explicit parameter list rather than a hash." do
-    expected = Aquarium::Finders::MethodFinder.new.find :types => ClassWithPrivateInstanceMethod, 
-      :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by ClassWithPrivateInstanceMethod, 
-      /test_method/, :private, :instance, :exclude_ancestor_methods
-    actual.should == expected
-
-    expected = Aquarium::Finders::MethodFinder.new.find :objects => @pub, 
-      :methods => /test_method/, :options => [:private, :instance, :exclude_ancestor_methods]
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by @pub, 
-      /test_method/, :private, :instance, :exclude_ancestor_methods
-    actual.should == expected
-
-    expected = Aquarium::Finders::MethodFinder.new.find :types => [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod], 
-      :methods => ["foo", /test_method/], :options => [:instance, :exclude_ancestor_methods]
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by [ClassWithPublicInstanceMethod, ClassWithPrivateInstanceMethod],
-      ["foo", /test_method/], :instance, :exclude_ancestor_methods
-    actual.should == expected
-
-    expected = Aquarium::Finders::MethodFinder.new.find :objects => [@pub, @pri], 
-      :methods => ["foo", /test_method/], :options => [:instance, :exclude_ancestor_methods]
-    actual = Aquarium::Finders::MethodFinder.new.find_all_by [@pub, @pri],
-      ["foo", /test_method/], :instance, :exclude_ancestor_methods
-    actual.should == expected
-  end
-end
   
 describe "Aquarium::Finders::MethodFinder.is_recognized_method_option" do
 

data/spec/aquarium/finders/type_finder_spec.rb

@@ -1,7 +1,14 @@
 require File.dirname(__FILE__) + '/../spec_helper.rb'
 require 'aquarium/finders/type_finder'
 
-describe Aquarium::Finders::TypeFinder, "#find" do
+class Outside
+  class Inside1; end
+  class Inside2
+    class ReallyInside; end
+  end
+end
+
+describe Aquarium::Finders::TypeFinder, "#find invocation parameters" do
 
   it "should raise if an uknown option is specified." do
     lambda { Aquarium::Finders::TypeFinder.new.find :foo => 'bar', :baz => ''}.should raise_error(Aquarium::Utils::InvalidOptions)
@@ -11,6 +18,10 @@ describe Aquarium::Finders::TypeFinder, "#find" do
     lambda { Aquarium::Finders::TypeFinder.new.find "foo" }.should raise_error(Aquarium::Utils::InvalidOptions)
   end
   
+  it "should raise if the input type value is nil." do
+    lambda { Aquarium::Finders::TypeFinder.new.find :type => nil }.should raise_error(Aquarium::Utils::InvalidOptions)
+  end
+  
   it "should return no matched types and no unmatched type expressions by default (i.e., the input is empty)." do
     actual = Aquarium::Finders::TypeFinder.new.find
     actual.matched.should == {}
@@ -40,6 +51,15 @@ describe Aquarium::Finders::TypeFinder, "#find" do
     actual.matched.should == {}
     actual.not_matched.should == {}
   end
+
+  it "should accept a hash and treat it as equivalent to an explicit list parameters." do
+    expected_found_types  = [Outside::Inside1, Outside::Inside2]
+    expected_unfound_exps = %w[Foo::Bar::Baz]
+    hash = {:names => (expected_found_types.map {|t| t.to_s} + expected_unfound_exps)}
+    actual = Aquarium::Finders::TypeFinder.new.find hash
+    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    actual.not_matched_keys.sort.should == expected_unfound_exps.sort
+  end
 end
 
 describe Aquarium::Finders::TypeFinder, "#is_recognized_option" do
@@ -59,12 +79,6 @@ describe Aquarium::Finders::TypeFinder, "#is_recognized_option" do
   end
 end
 
-class Outside
-  class Inside1; end
-  class Inside2
-    class ReallyInside; end
-  end
-end
 
 describe Aquarium::Finders::TypeFinder, "#find with :type or :name used to specify a single type" do
   it "should find a type matching a simple name (without :: namespace delimiters) using its name and the :type option." do
@@ -123,7 +137,8 @@ describe Aquarium::Finders::TypeFinder, "#find with :types, :names, :type, and :
     expected_found_types  = [FalseClass, Module, TrueClass]
     expected_unfound_exps = []
     actual = Aquarium::Finders::TypeFinder.new.find :types => [/eClass$/, /^Modu/]
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
+    expected_found_types.each {|t| actual.matched_keys.should include(t)}
+    # actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
     actual.not_matched_keys.sort.should == expected_unfound_exps.sort
   end
   
@@ -209,87 +224,8 @@ describe Aquarium::Finders::TypeFinder, "#find" do
   end
 end
 
-describe Aquarium::Finders::TypeFinder, "#find_all_by" do
-  it "should find types with :: namespace delimiters using lists of regular expressions." do
-    expected_found_types  = [Outside::Inside1, Outside::Inside2]
-    expected_unfound_exps = [/^.*Fo+::.*Bar+::Baz.$/]
-    actual = Aquarium::Finders::TypeFinder.new.find_all_by [/^.*Fo+::.*Bar+::Baz.$/, /Outside::.*1$/, /Out.*::In.*2/]
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
-    actual.not_matched_keys.should == expected_unfound_exps
-  end
-  
-  it "should find types with :: namespace delimiters using their names." do
-    expected_found_types  = [Outside::Inside1, Outside::Inside2]
-    expected_unfound_exps = %w[Foo::Bar::Baz]
-    actual = Aquarium::Finders::TypeFinder.new.find_all_by(expected_found_types.map {|t| t.to_s} + expected_unfound_exps)
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
-    actual.not_matched_keys.should == expected_unfound_exps
-  end
-
-  it "should find types when types given." do
-    expected_found_types  = [Outside::Inside1, Outside::Inside2]
-    actual = Aquarium::Finders::TypeFinder.new.find_all_by expected_found_types
-    actual.matched_keys.sort_by {|x| x.to_s}.should == expected_found_types.sort_by {|x| x.to_s}
-    actual.not_matched_keys.should == []
-  end
-end
-
-describe Aquarium::Finders::TypeFinder, "#find_by_name" do
-  it "should find a single type when given a single type name." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name("String")
-    actual.matched_keys.should == [String]
-    actual.not_matched_keys.should == []
-    actual = tf.find_by_name("Kernel")
-    actual.matched_keys.should == [Kernel]
-    actual.not_matched_keys.should == []
-    actual = tf.find_by_name("Module")
-    actual.matched_keys.should == [Module]
-    actual.not_matched_keys.should == []
-  end
-
-  it "should find a single type when given a valid type name with :: separators." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name "Outside::Inside1"
-    actual.matched_keys.should == [Outside::Inside1]
-    actual.not_matched_keys.should == []
-  end
-
-  it "should find a single type when given that type." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name Outside::Inside1
-    actual.matched_keys.should == [Outside::Inside1]
-    actual.not_matched_keys.should == []
-  end
-
-  it "should return no matches if the type can't be found." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name "UnknownClass1::UnknownClass2"
-    actual.matched_keys.should == []
-    actual.not_matched_keys.should == ["UnknownClass1::UnknownClass2"]
-  end
-
-  it "should return no matches if the type name is invalid." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name "$foo:bar"
-    actual.matched_keys.should == []
-    actual.not_matched_keys.should == ["$foo:bar"]
-  end
-end
-
-describe Aquarium::Finders::TypeFinder, "#find_by_type" do
-  it "is synonymous with find_by_name." do
-    tf = Aquarium::Finders::TypeFinder.new
-    actual = tf.find_by_name "Outside::Inside1"
-    actual.matched_keys.should == [Outside::Inside1]
-    actual.not_matched_keys.should == []
-    actual = tf.find_by_name Outside::Inside1
-    actual.matched_keys.should == [Outside::Inside1]
-    actual.not_matched_keys.should == []
-  end
-end
 
-# This is a spec for a protected method.
+# This is a spec for a protected method. It's primarily to keep the code coverage 100%, because there is rarely-invoked error handling code...
 describe Aquarium::Finders::TypeFinder, "#get_type_from_parent should" do
   it "should raise if a type doesn't exist that matches the constant" do
     lambda {Aquarium::Finders::TypeFinder.new.send(:get_type_from_parent, Aquarium::Finders, "Nonexistent", /Non/)}.should raise_error(NameError)