cohort_analysis 0.4.0 → 1.0.0

data/test/test_cohort_analysis.rb

@@ -1,222 +1,310 @@
 require 'helper'
 
-c = ActiveRecord::Base.connection
-c.create_table 'flights', :force => true do |t|
-  t.string 'origin'
-  t.string 'dest'
-  t.string 'airline'
-  t.string 'plane'
-end
-
 class Flight < ActiveRecord::Base
+  col :origin
+  col :dest
+  col :year, :type => :integer
+  col :airline
+  col :origin_city
+  col :dest_city
 end
+Flight.auto_upgrade!
 
 FactoryGirl.define do
-  factory :lax, :class => Flight do
-    origin 'LAX'
-  end
   factory :lax_sfo, :class => Flight do
     origin 'LAX'
     dest 'SFO'
   end
-  factory :lax_sfo_co, :class => Flight do
+  factory :lax_ord, :class => Flight do
     origin 'LAX'
-    dest 'SFO'
-    airline 'Continental'
+    dest 'ORD'
   end
-  factory :lax_sfo_a320, :class => Flight do
-    origin 'LAX'
+  factory :ord_sfo, :class => Flight do
+    origin 'ORD'
     dest 'SFO'
-    plane 'A320'
-  end
-  factory :lax_sfo_aa_a320, :class => Flight do
-    origin 'LAX'
-    dest 'SFO'
-    airline 'American'
-    plane 'A320'
   end
 end
 
-describe CohortAnalysis do
-  before do
-    Flight.delete_all
+shared_examples_for 'an adapter the provides #cohort' do
+  def moot_condition
+    Arel.sql('9 = 9')
   end
 
-  describe 'ActiveRecordBaseClassMethods' do
-    describe :cohort do
-      it "defaults to :minimum_size => 1" do
-        FactoryGirl.create(:lax)
-        Flight.cohort({:origin => 'LAX'}).count.must_equal 1
-        Flight.cohort({:origin => 'LAX'}, :minimum_size => 2).count.must_equal 0
-      end
+  describe :cohort do
+    it "finds the biggest set of records matching the characteristics" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      assert_count 2, model.cohort(:origin => 'LAX')
+      assert_count 1, model.cohort(:dest => 'SFO')
+      assert_count 1, model.cohort(:origin => 'LAX', :dest => 'SFO')
+      assert_count 0, model.cohort(:dest => 'MSN')
+    end
 
-      it "doesn't discard characteristics if it doesn't need to" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        Flight.cohort(:origin => 'LAX', :dest => 'SFO').count.must_equal 1
-      end
+    it "handles arrays of values" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      assert_count 2, model.cohort(:dest => ['ORD','SFO'])
+      assert_count 2, model.cohort(:origin => ['LAX'])
+      assert_count 1, model.cohort(:dest => ['SFO'])
+      assert_count 1, model.cohort(:origin => ['LAX'], :dest => ['SFO'])
+      assert_count 0, model.cohort(:dest => ['MSN'])
+      assert_count 1, model.cohort(:dest => ['MSN','SFO'])
+    end
 
-      it "discards characteristics until it can fulfil the minimum size" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        drops_dest = Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2)
-        drops_dest.count.must_equal 2
-        drops_dest.one? { |flight| flight.dest != 'SFO' }.must_equal true
-      end
+    it "matches everything if empty characteristics" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      assert_count 2, model.cohort({})
+    end
+
+    it "discards characteristics to maximize size until the minimum size is met" do
+      a = FactoryGirl.create(:lax_ord)
+      b = FactoryGirl.create(:lax_sfo)
+      cohort = model.cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2)
+      assert_count 2, cohort
+      assert_members [a,b], cohort
+    end
+
+    it "returns an empty cohort (basically an impossible condition) unless the minimum size is set" do
+      FactoryGirl.create(:lax_ord)
+      cohort = model.cohort({:origin => 'LAX'}, :minimum_size => 2)
+      assert_count 0, cohort
+    end
+
+    it "discards characteristics in order until a minimum size is met" do
+      a = FactoryGirl.create(:lax_ord)
+      b = FactoryGirl.create(:lax_sfo)
+      cohort = model.cohort({:origin => 'LAX', :dest => 'MSN'}, :minimum_size => 2, :priority => [:origin, :dest])
+      assert_count 2, cohort
+      assert_members [a,b], cohort
+    end
+
+    it "returns an empty cohort if discarding characteristics in order has that effect" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      cohort = model.cohort({:origin => 'LAX', :dest => 'MSN'}, :minimum_size => 2, :priority => [:dest, :origin])
+      assert_count 0, cohort
+    end
+
+    it "obeys conditions already added" do
+      FactoryGirl.create(:lax_ord, :year => 1900)
+      FactoryGirl.create(:lax_sfo, :year => 1900)
+      FactoryGirl.create(:lax_sfo, :year => 2009)
+      FactoryGirl.create(:ord_sfo, :year => 2009)
+      year_is_2009 = f_t[:year].eq(2009)
+
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX').where(moot_condition)
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX', :dest => 'MSN').where(moot_condition)
+
+      assert_count 1, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'MSN'}, :priority => [:origin, :dest]).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'MSN'}, :priority => [:dest, :origin]).where(moot_condition)
+
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX'}, :minimum_size => 2).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'MSN'}, :minimum_size => 2).where(moot_condition)
+      
+
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX').where(moot_condition)
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX', :dest => 'SFO').where(moot_condition)
+
+      assert_count 1, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'SFO'}, :priority => [:origin, :dest]).where(moot_condition)
+      assert_count 1, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'SFO'}, :priority => [:dest, :origin]).where(moot_condition)
+
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX'}, :minimum_size => 2).where(moot_condition)
+      assert_count 2, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2).where(moot_condition)
+
+
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX').where(moot_condition)
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'LAX', :dest => 'ORD').where(moot_condition)
+
+      assert_count 1, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'ORD'}, :priority => [:origin, :dest]).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'ORD'}, :priority => [:dest, :origin]).where(moot_condition)
+
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX'}, :minimum_size => 2).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'LAX', :dest => 'ORD'}, :minimum_size => 2).where(moot_condition)
+
+
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'ORD').where(moot_condition)
+      assert_count 1, model.where(year_is_2009).cohort(:origin => 'ORD', :dest => 'MSN').where(moot_condition)
+
+      assert_count 1, model.where(year_is_2009).cohort({:origin => 'ORD', :dest => 'MSN'}, :priority => [:origin, :dest]).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'ORD', :dest => 'MSN'}, :priority => [:dest, :origin]).where(moot_condition)
+
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'ORD'}, :minimum_size => 2).where(moot_condition)
+      assert_count 0, model.where(year_is_2009).cohort({:origin => 'ORD', :dest => 'MSN'}, :minimum_size => 2).where(moot_condition)
+    end
+
+    it "carries over into conditions added later" do
+      FactoryGirl.create(:lax_ord, :year => 1900)
+      FactoryGirl.create(:lax_sfo, :year => 1900)
+      FactoryGirl.create(:lax_sfo, :year => 2009)
+      FactoryGirl.create(:ord_sfo, :year => 2009)
+      year_is_2009 = f_t[:year].eq(2009)
+
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX').where(year_is_2009)
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX', :dest => 'MSN').where(year_is_2009)
 
-      it "defaults to :strategy => :big" do
-        FactoryGirl.create(:lax)
-        Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :strategy => :big).count.must_equal Flight.cohort(:origin => 'LAX', :dest => 'SFO').count
-        Flight.cohort({:dest => 'SFO', :origin => 'LAX'}, :strategy => :big).count.must_equal Flight.cohort(:dest => 'SFO', :origin => 'LAX').count
+      assert_count 1, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'MSN'}, :priority => [:origin, :dest]).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'MSN'}, :priority => [:dest, :origin]).where(year_is_2009)
+
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX'}, :minimum_size => 2).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'MSN'}, :minimum_size => 2).where(year_is_2009)
+      
+
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX').where(year_is_2009)
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX', :dest => 'SFO').where(year_is_2009)
+
+      assert_count 1, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'SFO'}, :priority => [:origin, :dest]).where(year_is_2009)
+      assert_count 1, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'SFO'}, :priority => [:dest, :origin]).where(year_is_2009)
+
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX'}, :minimum_size => 2).where(year_is_2009)
+      assert_count 2, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2).where(year_is_2009)
+
+
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX').where(year_is_2009)
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'LAX', :dest => 'ORD').where(year_is_2009)
+
+      assert_count 1, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'ORD'}, :priority => [:origin, :dest]).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'ORD'}, :priority => [:dest, :origin]).where(year_is_2009)
+
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX'}, :minimum_size => 2).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'LAX', :dest => 'ORD'}, :minimum_size => 2).where(year_is_2009)
+
+
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'ORD').where(year_is_2009)
+      assert_count 1, model.where(moot_condition).cohort(:origin => 'ORD', :dest => 'MSN').where(year_is_2009)
+
+      assert_count 1, model.where(moot_condition).cohort({:origin => 'ORD', :dest => 'MSN'}, :priority => [:origin, :dest]).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'ORD', :dest => 'MSN'}, :priority => [:dest, :origin]).where(year_is_2009)
+
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'ORD'}, :minimum_size => 2).where(year_is_2009)
+      assert_count 0, model.where(moot_condition).cohort({:origin => 'ORD', :dest => 'MSN'}, :minimum_size => 2).where(year_is_2009)
+    end
+
+    it "can get where sql" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      model.cohort(:origin => 'LAX').where_sql.must_equal %{WHERE ("flights"."origin" = 'LAX')}
+    end
+
+    it "will resolve independently from other cohorts" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_sfo)
+      assert_count 0, model.cohort(:dest => 'SFO').cohort(:dest => 'ORD')
+    end
+
+    it "will resolve independently from other cohorts (complex example)" do
+      FactoryGirl.create(:lax_ord)
+      FactoryGirl.create(:lax_ord, :origin_city => 'Los Angeles', :airline => 'Delta')
+      FactoryGirl.create(:lax_sfo)
+      FactoryGirl.create(:lax_ord, :origin_city => 'Los Angeles', :airline => 'Delta', :year => 2000)
+      FactoryGirl.create(:lax_sfo, :year => 2000)
+      year_condition = f_t[:year].eq(2000)
+
+      # sanity check
+      assert_count 2, model.where(year_condition)
+      assert_count 2, model.cohort(:origin => 'LAX', :dest => 'SFO')
+      assert_count 2, model.cohort(:origin_city => 'Los Angeles', :airline => 'Delta')
+      
+      assert_count 1, model.cohort(:origin => 'LAX', :dest => 'SFO').where(year_condition)
+      assert_count 1, model.where(year_condition).cohort(:origin => 'LAX', :dest => 'SFO')
+      
+      assert_count 2, model.cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2).where(year_condition)
+      assert_count 2, model.where(year_condition).cohort({:origin => 'LAX', :dest => 'SFO'}, :minimum_size => 2)
+
+      assert_count 1, model.cohort(:origin_city => 'Los Angeles', :airline => 'Delta').where(year_condition)
+      assert_count 1, model.where(year_condition).cohort(:origin_city => 'Los Angeles', :airline => 'Delta')
+      
+      assert_count 1, model.cohort(:origin_city => 'Los Angeles', :airline => 'Delta').where(year_condition)
+      assert_count 1, model.where(year_condition).cohort(:origin_city => 'Los Angeles', :airline => 'Delta')
+      #--
+
+      assert_count 0, model.cohort(:origin => 'LAX', :dest => 'SFO').cohort(:origin_city => 'Los Angeles', :airline => 'Delta')
+      assert_count 0, model.cohort(:origin_city => 'Los Angeles', :airline => 'Delta').cohort(:origin => 'LAX', :dest => 'SFO')
+    end
+
+    describe "when used with UNION" do
+      before do
+        @ord = FactoryGirl.create(:lax_ord)
+        @sfo = FactoryGirl.create(:lax_sfo)
       end
 
-      it "offers :strategy => :strict" do
-        FactoryGirl.create(:lax)
-        if RUBY_VERSION >= '1.9'
-          # native ordered hashes
-          Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :strategy => :strict).count.must_equal 1
-          Flight.cohort({:dest => 'SFO', :origin => 'LAX'}, :strategy => :strict).count.must_equal 0
-        else
-          # activesupport provides ActiveSupport::OrderedHash
-          origin_important = ActiveSupport::OrderedHash.new
-          origin_important[:origin] = 'LAX'
-          origin_important[:dest] = 'SFO'
-          dest_important = ActiveSupport::OrderedHash.new
-          dest_important[:dest] = 'SFO'
-          dest_important[:origin] = 'LAX'
-          Flight.cohort(origin_important, :strategy => :strict).count.must_equal 1
-          Flight.cohort(dest_important, :strategy => :strict).count.must_equal 0
-
-          lambda {
-            Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :strategy => :strict).count
-          }.must_raise(ArgumentError, 'hash')
-        end
+      # sanity check!
+      it "has tests that use unions properly" do
+        ord = model.where(f_t[:dest].eq('ORD')).project(Arel.star)
+        sfo = model.where(f_t[:dest].eq('SFO')).project(Arel.star)
+        Flight.find_by_sql("SELECT * FROM #{ord.union(sfo).to_sql}").must_equal [@ord, @sfo]
       end
+        
+      it "builds successful cohorts" do
+        ord = model.cohort(:dest => 'ORD').project(Arel.star)
+        sfo = model.cohort(:dest => 'SFO').project(Arel.star)
+        Flight.find_by_sql("SELECT * FROM #{ord.union(sfo).to_sql}").must_equal [@ord, @sfo]
 
-      it "lets you pick :priority of keys when using :strict strategy" do
-        FactoryGirl.create(:lax)
-        Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :strategy => :strict, :priority => [:origin, :dest]).count.must_equal 1
-        Flight.cohort({:origin => 'LAX', :dest => 'SFO'}, :strategy => :strict, :priority => [:dest, :origin]).count.must_equal 0
-        Flight.cohort({:dest => 'SFO', :origin => 'LAX'}, :strategy => :strict, :priority => [:origin, :dest]).count.must_equal 1
-        Flight.cohort({:dest => 'SFO', :origin => 'LAX'}, :strategy => :strict, :priority => [:dest, :origin]).count.must_equal 0
+        msn = model.cohort(:origin => 'LAX', :dest => 'MSN').project(Arel.star)
+        lhr = model.cohort(:origin => 'LAX', :dest => 'LHR').project(Arel.star)
+        Flight.find_by_sql("SELECT * FROM #{msn.union(lhr).to_sql}").must_equal [@ord, @sfo]
       end
 
-      it "lets you play with more than 1 or 2 characteristics" do
-        ActiveRecord::Base.silence do
-          # make some fixtures
-          1_000.times { FactoryGirl.create(:lax) }
-          100.times { FactoryGirl.create(:lax_sfo) }
-          10.times { FactoryGirl.create(:lax_sfo_co) }
-          3.times { FactoryGirl.create(:lax_sfo_a320) }
-          1.times { FactoryGirl.create(:lax_sfo_aa_a320) }
-        end
-        Flight.count.must_equal 1_114 # sanity check
-
-        lax_sfo_aa_a320 = {:origin => 'LAX', :dest => 'SFO', :airline => 'American', :plane => 'A320'}
-        # don't discard anything
-        Flight.cohort(lax_sfo_aa_a320).count.must_equal 1
-        # discard airline
-        Flight.cohort(lax_sfo_aa_a320, :minimum_size => 2).count.must_equal 4
-        # discard plane and airline
-        Flight.cohort(lax_sfo_aa_a320, :minimum_size => 5).count.must_equal 114
-        # discard plane and airline and dest
-        Flight.cohort(lax_sfo_aa_a320, :minimum_size => 115).count.must_equal 1_114
-
-        lax_sfo_a320 = {:origin => 'LAX', :dest => 'SFO', :plane => 'A320'}
-        # don't discard anything
-        Flight.cohort(lax_sfo_a320).count.must_equal 4
-        # discard plane
-        Flight.cohort(lax_sfo_a320, :minimum_size => 5).count.must_equal 114
-        # discard plane and dest
-        Flight.cohort(lax_sfo_a320, :minimum_size => 115).count.must_equal 1_114
-
-        # off the rails here a bit
-        woah_lax_co_a320 = {:origin => 'LAX', :airline => 'Continental', :plane => 'A320'}
-        # discard plane
-        Flight.cohort(woah_lax_co_a320).count.must_equal 10
-        # discard plane and airline
-        Flight.cohort(woah_lax_co_a320, :minimum_size => 11).count.must_equal 1_114
+      it "doesn't somehow create unions with false positives" do
+        msn = model.cohort(:dest => 'MSN').project(Arel.star)
+        lhr = model.cohort(:dest => 'LHR').project(Arel.star)
+        ActiveRecord::Base.connection.select_value("SELECT COUNT(*) FROM #{msn.union(lhr).to_sql}").must_equal 0
       end
 
-      it "lets you play with multiple characteristics in :strategy => :strict" do
-        ActiveRecord::Base.silence do
-          # make some fixtures
-          1_000.times { FactoryGirl.create(:lax) }
-          100.times { FactoryGirl.create(:lax_sfo) }
-          10.times { FactoryGirl.create(:lax_sfo_co) }
-          3.times { FactoryGirl.create(:lax_sfo_a320) }
-          1.times { FactoryGirl.create(:lax_sfo_aa_a320) }
-        end
-
-        lax_sfo_aa_a320 = {:origin => 'LAX', :dest => 'SFO', :airline => 'American', :plane => 'A320'}
-        priority = [:origin, :dest, :airline, :plane]
-        # discard nothing
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority).count.must_equal 1
-        # (force) discard plane, then (force) discard airline
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority, :minimum_size => 2).count.must_equal 114
-        # (force) discard plane, then (force) discard airline, then (force) discard dest
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority, :minimum_size => 115).count.must_equal 1_114
-
-        priority = [:plane, :airline, :dest, :origin]
-        # discard nothing
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority).count.must_equal 1
-        # (force) discard origin, then (force) discard dest, then (force) discard airline
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority, :minimum_size => 2).count.must_equal 4
-        # gives up!
-        Flight.cohort(lax_sfo_aa_a320, :strategy => :strict, :priority => priority, :minimum_size => 5).count.must_equal 0
+      it "builds unions where only one side has rows" do
+        msn = model.cohort(:dest => 'MSN').project(Arel.star)
+        ord = model.cohort(:dest => 'ORD').project(Arel.star)
+        Flight.find_by_sql("SELECT * FROM #{msn.union(ord).to_sql}").must_equal [@ord]
       end
     end
+  end
+end
 
-    describe :cohort_constraint do
-      it "can be used like other ARel constraints" do
-        FactoryGirl.create(:lax)
-        Flight.where(Flight.cohort_constraint(:origin => 'LAX')).count.must_equal 1
-        Flight.where(Flight.cohort_constraint({:origin => 'LAX'}, :minimum_size => 2)).count.must_equal 0
-      end
+describe CohortAnalysis do
+  def assert_count(expected_count, relation)
+    relation = relation.clone
+    relation.projections = [Arel.sql('COUNT(*)')]
+    sql = relation.to_sql
+    ActiveRecord::Base.connection.select_value(sql).must_equal expected_count
+  end
 
-      it "can be combined with other ARel constraints" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        origin_lax_constraint = Flight.cohort_constraint(:origin => 'LAX')
-        dest_sfo_constraint = Flight.arel_table[:dest].eq('SFO')
-        Flight.where(dest_sfo_constraint.and(origin_lax_constraint)).count.must_equal 1
-        Flight.where(dest_sfo_constraint.or(origin_lax_constraint)).count.must_equal 2
-        Flight.where(origin_lax_constraint.and(dest_sfo_constraint)).count.must_equal 1
-        Flight.where(origin_lax_constraint.or(dest_sfo_constraint)).count.must_equal 2
-      end
+  def assert_members(expected_members, relation)
+    relation = relation.clone
+    table = relation.source.left
+    relation.projections = [Arel.star]
+    actual_members = Flight.find_by_sql relation.to_sql
+    actual_members.map(&:id).sort.must_equal expected_members.map(&:id).sort
+  end
 
-      # Caution!
-      it "is NOT smart enough to enforce minimum size when composed" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        origin_lax_constraint = Flight.cohort_constraint({:origin => 'LAX'}, :minimum_size => 2)
-        dest_sfo_constraint = Flight.arel_table[:dest].eq('SFO')
-        Flight.where(dest_sfo_constraint.and(origin_lax_constraint)).count.must_equal 1 # see how minimum_size is ignored?
-        Flight.where(origin_lax_constraint.and(dest_sfo_constraint)).count.must_equal 1 # it's because the cohort constraint resolves itself before allowing the ARel visitor to continue
-      end
+  def f_t
+    Arel::Table.new(:flights)
+  end
+
+  describe 'ArelSelectManagerInstanceMethods' do
+    it_behaves_like 'an adapter the provides #cohort'
+    def model
+      Arel::SelectManager.new(ActiveRecord::Base, Arel::Table.new(:flights))
     end
   end
 
-  describe 'ActiveRecordRelationInstanceMethods' do
-    describe :cohort do
-      it "is the proper way to compose when other ARel constraints are present" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        Flight.where(:dest => 'SFO').cohort(:origin => 'LAX').count.must_equal 1
-        Flight.where(:dest => 'SFO').cohort({:origin => 'LAX'}, :minimum_size => 2).count.must_equal 0
-      end
+  describe 'ArelTableInstanceMethods' do
+    it_behaves_like 'an adapter the provides #cohort'
+    def model
+      Arel::Table.new(:flights, ActiveRecord::Base)
     end
-    describe :cohort_constraint do
-      it "can also be used (carefully) to compose with other ARel constraints" do
-        FactoryGirl.create(:lax)
-        FactoryGirl.create(:lax_sfo)
-        dest_sfo_relation = Flight.where(:dest => 'SFO')
-        origin_lax_constraint_from_dest_sfo_relation = dest_sfo_relation.cohort_constraint(:origin => 'LAX')
-        Flight.where(origin_lax_constraint_from_dest_sfo_relation).count.must_equal 1
-        dest_sfo_relation = Flight.where(:dest => 'SFO')
-        origin_lax_constraint_from_dest_sfo_relation = dest_sfo_relation.cohort_constraint({:origin => 'LAX'}, :minimum_size => 2)
-        Flight.where(origin_lax_constraint_from_dest_sfo_relation).count.must_equal 0
-      end
+  end
+
+  describe 'ActiveRecordBaseClassMethods' do
+    it_behaves_like 'an adapter the provides #cohort'
+    def model
+      Flight
+    end
+  end
+
+  describe 'ActiveRecordRelationInstanceMethods' do
+    it_behaves_like 'an adapter the provides #cohort'
+    def model
+      Flight.scoped
     end
   end
 end