linkage 0.0.6 → 0.0.8

data/test/integration/test_within_comparator.rb

@@ -0,0 +1,100 @@
+require 'helper'
+
+module IntegrationTests
+  class TestWithinComparator < Test::Unit::TestCase
+    test "within comparator with no simple expectations" do
+      database_for('sqlite') do |db|
+        db.create_table(:foo) { primary_key(:id); Integer(:num) }
+        db.create_table(:bar) { primary_key(:id); Integer(:num) }
+        db[:foo].import([:id, :num], (1..10).collect { |i| [i, i] })
+        db[:bar].import([:id, :num], (1..10).collect { |i| [i, i] })
+      end
+
+      db_opts = database_options_for('sqlite')
+      dataset_1 = Linkage::Dataset.new(db_opts, "foo")
+      dataset_2 = Linkage::Dataset.new(db_opts, "bar")
+      conf = dataset_1.link_with(dataset_2) do
+        lhs[:num].must be_within(5).of(rhs[:num])
+        save_results_in(db_opts)
+      end
+
+      runner = Linkage::SingleThreadedRunner.new(conf)
+      runner.execute
+
+      database_for('sqlite') do |db|
+        assert_equal db[:scores].count, 100
+        db[:scores].order(:record_1_id, :record_2_id).each do |score|
+          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
+            assert_equal 1, score[:score], score.inspect
+          else
+            assert_equal 0, score[:score], score.inspect
+          end
+        end
+      end
+    end
+
+    test "within comparator with simple expectations" do
+      database_for('sqlite') do |db|
+        db.create_table(:foo) { primary_key(:id); Integer(:num); String(:parity) }
+        db.create_table(:bar) { primary_key(:id); Integer(:num); String(:parity)  }
+        db[:foo].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
+        db[:bar].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
+      end
+
+      db_opts = database_options_for('sqlite')
+      dataset_1 = Linkage::Dataset.new(db_opts, "foo")
+      dataset_2 = Linkage::Dataset.new(db_opts, "bar")
+      conf = dataset_1.link_with(dataset_2) do
+        lhs[:parity].must == rhs[:parity]
+        lhs[:num].must be_within(5).of(rhs[:num])
+        save_results_in(db_opts)
+      end
+
+      runner = Linkage::SingleThreadedRunner.new(conf)
+      runner.execute
+
+      database_for('sqlite') do |db|
+        assert_equal db[:scores].count, 50
+        db[:scores].order(:record_1_id, :record_2_id).each do |score|
+          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
+            assert_equal 1, score[:score]
+          else
+            assert_equal 0, score[:score]
+          end
+        end
+      end
+    end
+
+    test "within comparator with simple expectations and functions" do
+      database_for('sqlite') do |db|
+        db.create_table(:foo) { primary_key(:id); Integer(:num); String(:parity) }
+        db.create_table(:bar) { primary_key(:id); Integer(:num); String(:parity)  }
+        db[:foo].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
+        db[:bar].import([:id, :num, :parity], (1..10).collect { |i| [i, i, i % 2 == 0 ? "even" : "odd"] })
+      end
+
+      db_opts = database_options_for('sqlite')
+      dataset_1 = Linkage::Dataset.new(db_opts, "foo")
+      dataset_2 = Linkage::Dataset.new(db_opts, "bar")
+      conf = dataset_1.link_with(dataset_2) do
+        lhs[:parity].must == rhs[:parity]
+        cast(lhs[:num], 'integer').must be_within(5).of(cast(rhs[:num], 'integer'))
+        save_results_in(db_opts)
+      end
+
+      runner = Linkage::SingleThreadedRunner.new(conf)
+      runner.execute
+
+      database_for('sqlite') do |db|
+        assert_equal db[:scores].count, 50
+        db[:scores].order(:record_1_id, :record_2_id).each do |score|
+          if (score[:record_2_id] - score[:record_1_id]).abs <= 5
+            assert_equal 1, score[:score]
+          else
+            assert_equal 0, score[:score]
+          end
+        end
+      end
+    end
+  end
+end

data/test/unit/comparators/test_compare.rb

@@ -0,0 +1,105 @@
+require 'helper'
+
+class UnitTests::TestCompare < Test::Unit::TestCase
+  def self.const_missing(name)
+    if Linkage::Comparators.const_defined?(name)
+      Linkage::Comparators.const_get(name)
+    else
+      super
+    end
+  end
+
+  test "subclass of Binary" do
+    assert_equal Binary, Compare.superclass
+  end
+
+  test "valid parameters" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '>', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    assert_nothing_raised do
+      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+
+  test "score for not equal to" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '!=', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 1, comp.score({:foo => 10}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 5}, {:bar => 5})
+    assert_equal 1, comp.score({:foo => 0}, {:bar => 5})
+  end
+
+  test "score for greater than" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '>', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 1, comp.score({:foo => 10}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 5}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 0}, {:bar => 5})
+  end
+
+  test "score for greater than or equal to" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '>=', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 1, comp.score({:foo => 10}, {:bar => 5})
+    assert_equal 1, comp.score({:foo => 5}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 0}, {:bar => 5})
+  end
+
+  test "score for less than or equal to" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '<=', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 0, comp.score({:foo => 10}, {:bar => 5})
+    assert_equal 1, comp.score({:foo => 5}, {:bar => 5})
+    assert_equal 1, comp.score({:foo => 0}, {:bar => 5})
+  end
+
+  test "score for less than" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '<', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 0, comp.score({:foo => 10}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 5}, {:bar => 5})
+    assert_equal 1, comp.score({:foo => 0}, {:bar => 5})
+  end
+
+  test "registers itself" do
+    assert_equal Compare, Linkage::Comparator['compare']
+  end
+
+  test "requires argument from each side" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '>=', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    assert_raises do
+      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+
+  test "requires that 3rd argument has the same type as the first argument" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => '>=', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Date }, :static? => false)
+    assert_raises do
+      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+
+  test "requires raw operator to be >, >=, <=, <, or !=" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => 'foo', :ruby_type => { :type => String }, :static? => true, :raw? => true)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    assert_raises do
+      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+end

data/test/unit/comparators/test_within.rb

@@ -0,0 +1,57 @@
+require 'helper'
+
+class UnitTests::TestWithin < Test::Unit::TestCase
+  def self.const_missing(name)
+    if Linkage::Comparators.const_defined?(name)
+      Linkage::Comparators.const_get(name)
+    else
+      super
+    end
+  end
+
+  test "subclass of Binary" do
+    assert_equal Linkage::Comparators::Binary, Within.superclass
+  end
+
+  test "valid parameters" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => 123, :ruby_type => { :type => Fixnum }, :static? => true, :object => 123)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    assert_nothing_raised do
+      Within.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+
+  test "score" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => 123, :ruby_type => { :type => Fixnum }, :static? => true, :object => 123)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Integer }, :static? => false)
+    comp = Within.new(meta_object_1, meta_object_2, meta_object_3)
+    assert_equal 1, comp.score({:foo => 123}, {:bar => 124})
+    assert_equal 1, comp.score({:foo => 124}, {:bar => 123})
+    assert_equal 1, comp.score({:foo => 0}, {:bar => 123})
+    assert_equal 0, comp.score({:foo => 0}, {:bar => 124})
+  end
+
+  test "registers itself" do
+    assert_equal Within, Linkage::Comparator['within']
+  end
+
+  test "requires argument from each side" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => 123, :ruby_type => { :type => Fixnum }, :static? => true, :object => 123)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    assert_raises do
+      Within.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+
+  test "requires that 3rd argument has the same type as the first argument" do
+    meta_object_1 = stub('meta object', :name => :foo, :side => :lhs, :ruby_type => { :type => Integer }, :static? => false)
+    meta_object_2 = stub('meta object', :object => 123, :ruby_type => { :type => Fixnum }, :static? => true, :object => 123)
+    meta_object_3 = stub('meta object', :name => :bar, :side => :rhs, :ruby_type => { :type => Date }, :static? => false)
+    assert_raises do
+      Within.new(meta_object_1, meta_object_2, meta_object_3)
+    end
+  end
+end

data/test/unit/expectations/test_exhaustive.rb

@@ -0,0 +1,111 @@
+require 'helper'
+
+class UnitTests::TestExhaustive < Test::Unit::TestCase
+  test "initialize with comparator, threshold, and mode" do
+    comparator = stub('comparator')
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal comparator, exp.comparator
+    assert_equal 100, exp.threshold
+    assert_equal :min, exp.mode
+  end
+
+  test "kind is :self when comparator has same args on both sides" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(true)
+    comparator = stub('comparator', {
+      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
+    })
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal :self, exp.kind
+  end
+
+  test "kind is :cross when comparator has args with same dataset but different number of args" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    meta_object_3 = stub('meta object 3')
+    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(true)
+    comparator = stub('comparator', {
+      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2, meta_object_3]
+    })
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal :cross, exp.kind
+  end
+
+  test "kind is :cross when comparator has args with same dataset but different objects" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(false)
+    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(true)
+    comparator = stub('comparator', {
+      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
+    })
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal :cross, exp.kind
+  end
+
+  test "kind is :dual when comparator has args with different datasets and different number of args" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    meta_object_3 = stub('meta object 3')
+    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(false)
+    comparator = stub('comparator', {
+      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2, meta_object_3]
+    })
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal :dual, exp.kind
+  end
+
+  test "kind is :dual when comparator has args with different datasets" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(false)
+    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(false)
+    comparator = stub('comparator', {
+      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
+    })
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    assert_equal :dual, exp.kind
+  end
+
+  test "apply_to lhs dataset" do
+    dataset = stub('dataset')
+    new_dataset = stub('new dataset')
+    meta_object_1 = stub('meta object 1', :name => :foo, :to_expr => :foo)
+    meta_object_2 = stub('meta object 2', :name => :bar, :to_expr => :bar)
+    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    dataset.expects(:select_more).with(:foo.as(:foo)).returns(new_dataset)
+    assert_equal new_dataset, exp.apply_to(dataset, :lhs)
+  end
+
+  test "apply_to rhs dataset" do
+    dataset = stub('dataset')
+    new_dataset = stub('new dataset')
+    meta_object_1 = stub('meta object 1', :name => :foo, :to_expr => :foo)
+    meta_object_2 = stub('meta object 2', :name => :bar, :to_expr => :bar)
+    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
+    dataset.expects(:select_more).with(:bar.as(:bar)).returns(new_dataset)
+    assert_equal new_dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "satisfied? with :equal mode" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 50, :equal)
+    assert exp.satisfied?(50)
+    assert !exp.satisfied?(123)
+  end
+
+  test "satisfied? with :min mode" do
+    meta_object_1 = stub('meta object 1')
+    meta_object_2 = stub('meta object 2')
+    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
+    exp = Linkage::Expectations::Exhaustive.new(comparator, 50, :min)
+    assert exp.satisfied?(50)
+    assert exp.satisfied?(55)
+    assert !exp.satisfied?(45)
+  end
+end

data/test/unit/expectations/test_simple.rb

@@ -0,0 +1,303 @@
+require 'helper'
+
+class UnitTests::TestSimple < Test::Unit::TestCase
+  test "initialize with invalid operator" do
+    assert_raises(ArgumentError) do
+      Linkage::Expectations::Simple.new(stub(), stub(), :foo)
+    end
+  end
+
+  test "creating filter expectation from a dynamic object and a static object" do
+    field = stub('meta field', :static? => false, :side => :lhs)
+    object = stub('meta object', :static? => true)
+    exp = Linkage::Expectations::Simple.create(field, object, :==)
+    assert_kind_of Linkage::Expectations::Filter, exp
+    assert_equal :lhs, exp.side
+  end
+
+  test "creating expectation from two static objects raises error" do
+    object_1 = stub('meta object 1', :static? => true)
+    object_2 = stub('meta object 2', :static? => true)
+    assert_raises(ArgumentError) do
+      Linkage::Expectations::Simple.create(object_1, object_2, :==)
+    end
+  end
+
+  test "creating filter expectation from two dynamic objects with the same side" do
+    field_1 = stub('meta field 1', :static? => false, :side => :lhs)
+    field_2 = stub('meta field 2', :static? => false, :side => :lhs)
+    field_1.expects(:datasets_equal?).with(field_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(field_1, field_2, :==)
+    assert_kind_of Linkage::Expectations::Filter, exp
+    assert_equal :lhs, exp.side
+  end
+
+  test "creating filter expectation from two dynamic objects with the same side but different datasets raises error" do
+    field_1 = stub('meta field 1', :static? => false, :side => :lhs)
+    field_2 = stub('meta field 2', :static? => false, :side => :lhs)
+    field_1.expects(:datasets_equal?).with(field_2).returns(false)
+    assert_raises(ArgumentError) do
+      Linkage::Expectations::Simple.create(field_1, field_2, :==)
+    end
+  end
+
+  test "creating self expectation from two dynamic objects with different sides" do
+    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
+    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
+    object_1.expects(:objects_equal?).with(object_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+    assert_kind_of Linkage::Expectations::Self, exp
+  end
+
+  test "creating cross expectation from two dynamic objects with different sides but same dataset" do
+    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
+    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
+    object_1.expects(:objects_equal?).with(object_2).returns(false)
+    object_1.expects(:datasets_equal?).with(object_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+    assert_kind_of Linkage::Expectations::Cross, exp
+  end
+
+  test "creating dual expectation from two dynamic objects with different sides and datasets" do
+    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
+    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
+    object_1.expects(:objects_equal?).with(object_2).returns(false)
+    object_1.expects(:datasets_equal?).with(object_2).returns(false)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+    assert_kind_of Linkage::Expectations::Dual, exp
+  end
+
+  test "apply_to with filter expectation (== operator)" do
+    dataset = stub('dataset')
+    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
+    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
+    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
+
+    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :==)
+    meta_field_1.expects(:to_expr).returns(:foo)
+    meta_field_2.expects(:to_expr).returns(:bar)
+    dataset.expects(:filter).with({:foo => :bar}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :lhs)
+
+    dataset.expects(:filter).never
+    assert_equal dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "apply_to with filter expectation (!= operator)" do
+    dataset = stub('dataset')
+    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
+    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
+    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
+
+    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :'!=')
+    meta_field_1.expects(:to_expr).returns(:foo)
+    meta_field_2.expects(:to_expr).returns(:bar)
+    dataset.expects(:filter).with(~{:foo => :bar}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :lhs)
+
+    dataset.expects(:filter).never
+    assert_equal dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "apply_to with filter expectation (> operator)" do
+    dataset = stub('dataset')
+    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
+    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
+    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :>)
+
+    identifier_1 = Sequel::SQL::Identifier.new(:foo)
+    meta_field_1.expects(:to_identifier).returns(identifier_1)
+    identifier_2 = Sequel::SQL::Identifier.new(:bar)
+    meta_field_2.expects(:to_identifier).returns(identifier_2)
+    expected = Sequel::SQL::BooleanExpression.new(:>, identifier_1, identifier_2)
+
+    dataset.expects(:filter).with(expected).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :lhs)
+
+    dataset.expects(:filter).never
+    assert_equal dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "apply_to with self expectation" do
+    dataset = stub('dataset')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset,
+      :to_expr => :foo
+    })
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset,
+      :to_expr => :foo
+    })
+    object_1.expects(:objects_equal?).with(object_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+
+    merged_field = stub('merged field', :name => :foo)
+    object_1.expects(:merge).with(object_2).returns(merged_field)
+    dataset.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :lhs)
+
+    dataset.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "apply_to with cross expectation" do
+    dataset = stub('dataset')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset,
+      :to_expr => :foo
+    })
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset,
+      :to_expr => :bar
+    })
+    object_1.stubs(:objects_equal?).with(object_2).returns(false)
+    object_1.stubs(:datasets_equal?).with(object_2).returns(true)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+
+    merged_field = stub('merged field', :name => :foo_bar)
+    object_1.expects(:merge).with(object_2).returns(merged_field)
+    dataset.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo_bar}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :lhs)
+
+    dataset.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo_bar}).returns(dataset)
+    assert_equal dataset, exp.apply_to(dataset, :rhs)
+  end
+
+  test "apply_to with dual expectation" do
+    dataset_1 = stub('dataset 1')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset_1,
+      :to_expr => :foo
+    })
+    dataset_2 = stub('dataset 2')
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset_2,
+      :to_expr => :foo
+    })
+    object_1.stubs(:objects_equal?).with(object_2).returns(false)
+    object_1.stubs(:datasets_equal?).with(object_2).returns(false)
+    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
+
+    merged_field = stub('merged field', :name => :foo)
+    object_1.expects(:merge).with(object_2).returns(merged_field)
+    dataset_1.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo}).returns(dataset_1)
+    assert_equal dataset_1, exp.apply_to(dataset_1, :lhs)
+
+    dataset_2.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo}).returns(dataset_2)
+    assert_equal dataset_2, exp.apply_to(dataset_2, :rhs)
+  end
+
+  test "exactly! wraps each side inside the binary function" do
+    dataset_1 = stub('dataset 1')
+    field_1 = stub_field('field 1', :dataset => dataset_1)
+    meta_object_1 = stub('meta object 1', :static? => false, :side => :lhs,
+                         :object => field_1, :dataset => dataset_1)
+
+    dataset_2 = stub('dataset 2')
+    field_2 = stub_field('field 2', :dataset => dataset_2)
+    meta_object_2 = stub('meta object 2', :static? => false, :side => :rhs,
+                         :object => field_2, :dataset => dataset_2)
+    meta_object_1.stubs(:objects_equal?).with(meta_object_2).returns(true)
+
+    exp = Linkage::Expectations::Simple.create(meta_object_1, meta_object_2, :==)
+
+    klass = Linkage::Functions::Binary
+    func_1 = stub('binary function 1')
+    klass.expects(:new).with(field_1, :dataset => dataset_1).returns(func_1)
+    func_2 = stub('binary function 2')
+    klass.expects(:new).with(field_2, :dataset => dataset_2).returns(func_2)
+
+    new_meta_object_1 = stub('new meta object 1')
+    Linkage::MetaObject.expects(:new).with(func_1, :lhs).returns(new_meta_object_1)
+    new_meta_object_2 = stub('new meta object 2')
+    Linkage::MetaObject.expects(:new).with(func_2, :rhs).returns(new_meta_object_2)
+
+    exp.exactly!
+    # LAZY: assume the expectation set its meta objects appropriately
+  end
+
+  test "#same_except_side with two filter expectations" do
+    field = stub_field('foo')
+    meta_object_1 = stub('meta field 1', {
+      :static? => false, :side => :lhs, :object => field
+    })
+    meta_object_2 = stub('meta object', :static? => true)
+    meta_object_3 = stub('meta field 2', {
+      :static? => false, :side => :rhs, :object => field
+    })
+
+    exp_1 = Linkage::Expectations::Simple.create(meta_object_1, meta_object_2, :==)
+    exp_2 = Linkage::Expectations::Simple.create(meta_object_3, meta_object_2, :==)
+
+    meta_object_1.expects(:objects_equal?).with(meta_object_3).returns(true)
+    meta_object_2.expects(:objects_equal?).with(meta_object_2).returns(true)
+    assert exp_1.same_except_side?(exp_2)
+  end
+
+  test "#decollation_needed? is false when comparing non-string objects" do
+    dataset_1 = stub('dataset 1')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset_1,
+    })
+    dataset_2 = stub('dataset 2')
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset_2,
+    })
+    merged_field = stub('merged field', :ruby_type => {:type => Fixnum})
+    object_1.stubs(:merge).with(object_2).returns(merged_field)
+    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
+    assert !exp.decollation_needed?
+  end
+
+  test "#decollation_needed? is false when comparing two dynamic string objects with the same database type and same collation" do
+    dataset_1 = stub('dataset 1')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset_1,
+      :collation => 'foo', :database_type => :mysql
+    })
+    dataset_2 = stub('dataset 2')
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset_2,
+      :collation => 'foo', :database_type => :mysql
+    })
+    merged_field = stub('merged field', :ruby_type => {:type => String})
+    object_1.stubs(:merge).with(object_2).returns(merged_field)
+    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
+    assert !exp.decollation_needed?
+  end
+
+  test "#decollation_needed? is true when comparing two dynamic string objects with the same database type but different collations" do
+    dataset_1 = stub('dataset 1')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset_1,
+      :collation => 'foo', :database_type => :mysql
+    })
+    dataset_2 = stub('dataset 2')
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset_2,
+      :collation => 'bar', :database_type => :mysql
+    })
+    merged_field = stub('merged field', :ruby_type => {:type => String})
+    object_1.stubs(:merge).with(object_2).returns(merged_field)
+    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
+    assert exp.decollation_needed?
+  end
+
+  test "#decollation_needed? is true when comparing two dynamic string objects with same collation but different database types" do
+    dataset_1 = stub('dataset 1')
+    object_1 = stub('meta object 1', {
+      :static? => false, :side => :lhs, :dataset => dataset_1,
+      :collation => 'foo', :database_type => :foo
+    })
+    dataset_2 = stub('dataset 2')
+    object_2 = stub('meta object 2', {
+      :static? => false, :side => :rhs, :dataset => dataset_2,
+      :collation => 'foo', :database_type => :bar
+    })
+    merged_field = stub('merged field', :ruby_type => {:type => String})
+    object_1.stubs(:merge).with(object_2).returns(merged_field)
+    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
+    assert exp.decollation_needed?
+  end
+end