linkage 0.0.8 → 0.1.0.pre

data/test/unit/comparators/test_compare.rb

@@ -1,6 +1,6 @@
-require 'helper'
+require File.expand_path("../../test_comparators", __FILE__)
 
-class UnitTests::TestCompare < Test::Unit::TestCase
+class UnitTests::TestComparators::TestCompare < Test::Unit::TestCase
   def self.const_missing(name)
     if Linkage::Comparators.const_defined?(name)
       Linkage::Comparators.const_get(name)
@@ -9,97 +9,301 @@ class UnitTests::TestCompare < Test::Unit::TestCase
     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
+  test "subclass of Comparator" do
+    assert_equal Linkage::Comparator, Compare.superclass
   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)
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :not_equal)
+    assert_equal :simple, comp.type
     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 not equal to with multiple fields" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_3 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_4 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_3, field_4], :not_equal)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 10, :bar => 5}, {:baz => 5, :qux => 10})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 10, :qux => 5})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 10, :qux => 7})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 7, :qux => 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)
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :greater_than)
+    assert_equal :simple, comp.type
     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 with multiple fields" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_3 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_4 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_3, field_4], :greater_than)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 10, :bar => 5}, {:baz => 5, :qux => 0})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 15, :qux => 10})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 15, :qux => 0})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 5, :qux => 10})
+  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)
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :greater_than_or_equal)
+    assert_equal :simple, comp.type
     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 greater than or equal to with multiple fields" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_3 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_4 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_3, field_4], :greater_than_or_equal)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 10, :bar => 5}, {:baz => 5, :qux => 0})
+    assert_equal 1, comp.score({:foo => 10, :bar => 5}, {:baz => 10, :qux => 5})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 5, :qux => 10})
+    assert_equal 0, comp.score({:foo => 10, :bar => 5}, {:baz => 15, :qux => 0})
+  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})
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :less_than_or_equal)
+    assert_equal :simple, comp.type
     assert_equal 1, comp.score({:foo => 5}, {:bar => 5})
     assert_equal 1, comp.score({:foo => 0}, {:bar => 5})
+    assert_equal 0, comp.score({:foo => 10}, {:bar => 5})
+  end
+
+  test "score for less than or equal to with multiple fields" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_3 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_4 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_3, field_4], :less_than_or_equal)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 5, :bar => 0}, {:baz => 10, :qux => 5})
+    assert_equal 1, comp.score({:foo => 5, :bar => 0}, {:baz => 5, :qux => 0})
+    assert_equal 0, comp.score({:foo => 5, :bar => 0}, {:baz => 0, :qux => 5})
+    assert_equal 0, comp.score({:foo => 5, :bar => 0}, {:baz => 10, :qux => -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)
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :less_than)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 0}, {:bar => 5})
     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 "score for less than with multiple fields" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_3 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_4 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_3, field_4], :less_than)
+    assert_equal :simple, comp.type
+    assert_equal 1, comp.score({:foo => 5, :bar => 0}, {:baz => 10, :qux => 5})
+    assert_equal 0, comp.score({:foo => 5, :bar => 0}, {:baz => 5, :qux => 0})
+    assert_equal 0, comp.score({:foo => 5, :bar => 0}, {:baz => 0, :qux => 5})
+    assert_equal 0, comp.score({:foo => 5, :bar => 0}, {:baz => 10, :qux => -5})
+  end
+
+  test "score_datasets with one field equality" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :equal)
+    assert_equal :advanced, comp.type
+    observer = stub('observer', :update => nil)
+    comp.add_observer(observer)
+
+    dataset_1 = stub('dataset 1')
+    dataset_1.expects(:order).with(:foo).returns(dataset_1)
+    dataset_1.expects(:each).multiple_yields(
+      [(record_1_1 = {:id => 1, :foo => 123})],
+      [(record_1_2 = {:id => 2, :foo => 456})],
+      [(record_1_3 = {:id => 3, :foo => 456})]
+    )
+
+    dataset_2 = stub('dataset 2')
+    dataset_2.expects(:order).with(:bar).returns(dataset_2)
+    dataset_2.expects(:each).multiple_yields(
+      [(record_2_1 = {:id => 100, :bar => 123})],
+      [(record_2_2 = {:id => 101, :bar => 456})],
+      [(record_2_3 = {:id => 102, :bar => 456})]
+    )
+
+    observer.expects(:update).with(comp, record_1_1, record_2_1, 1)
+    observer.expects(:update).with(comp, record_1_2, record_2_2, 1)
+    observer.expects(:update).with(comp, record_1_2, record_2_3, 1)
+    observer.expects(:update).with(comp, record_1_3, record_2_2, 1)
+    observer.expects(:update).with(comp, record_1_3, record_2_3, 1)
+
+    comp.score_datasets(dataset_1, dataset_2)
+  end
+
+  test "score_datasets with multiple field equality" do
+    field_1_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_1_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    field_2_1 = stub('baz field', :name => :baz, :ruby_type => { :type => Integer })
+    field_2_2 = stub('qux field', :name => :qux, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1_1, field_1_2], [field_2_1, field_2_2], :equal)
+    assert_equal :advanced, comp.type
+    observer = stub('observer', :update => nil)
+    comp.add_observer(observer)
+
+    dataset_1 = stub('dataset 1')
+    dataset_1.expects(:order).with(:foo, :bar).returns(dataset_1)
+    dataset_1.expects(:each).multiple_yields(
+      [(record_1_1 = {:id => 1, :foo => 123, :bar => 123})],
+      [(record_1_2 = {:id => 2, :foo => 123, :bar => 456})],
+      [(record_1_3 = {:id => 3, :foo => 123, :bar => 789})],
+      [(record_1_4 = {:id => 4, :foo => 456, :bar => 123})]
+    )
+
+    dataset_2 = stub('dataset 2')
+    dataset_2.expects(:order).with(:baz, :qux).returns(dataset_2)
+    dataset_2.expects(:each).multiple_yields(
+      [(record_2_1 = {:id => 100, :baz => 123, :qux => 123})],
+      [(record_2_2 = {:id => 101, :baz => 123, :qux => 123})],
+      [(record_2_3 = {:id => 102, :baz => 123, :qux => 789})],
+      [(record_2_4 = {:id => 103, :baz => 456, :qux => 123})],
+      [(record_2_5 = {:id => 104, :baz => 456, :qux => 456})]
+    )
+
+    observer.expects(:update).with(comp, record_1_1, record_2_1, 1)
+    observer.expects(:update).with(comp, record_1_1, record_2_2, 1)
+    observer.expects(:update).with(comp, record_1_3, record_2_3, 1)
+    observer.expects(:update).with(comp, record_1_4, record_2_4, 1)
+
+    comp.score_datasets(dataset_1, dataset_2)
+  end
+
+  test "score_dataset with same single field equality" do
+    field = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    comp = Compare.new([field], [field], :equal)
+    assert_equal :advanced, comp.type
+    observer = stub('observer', :update => nil)
+    comp.add_observer(observer)
+
+    dataset = stub('dataset')
+    dataset.expects(:order).with(:foo).returns(dataset)
+    dataset.expects(:each).multiple_yields(
+      [(record_1 = {:id => 1, :foo => 123})],
+      [(record_2 = {:id => 2, :foo => 456})],
+      [(record_3 = {:id => 3, :foo => 456})]
+    )
+
+    observer.expects(:update).with(comp, record_2, record_3, 1)
+    comp.score_dataset(dataset)
+  end
+
+  test "score_dataset with same multiple field equality" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1, field_2], [field_1, field_2], :equal)
+    assert_equal :advanced, comp.type
+    observer = stub('observer', :update => nil)
+    comp.add_observer(observer)
+
+    dataset = stub('dataset')
+    dataset.expects(:order).with(:foo, :bar).returns(dataset)
+    dataset.expects(:each).multiple_yields(
+      [(record_1 = {:id => 1, :foo => 123, :bar => 123})],
+      [(record_2 = {:id => 2, :foo => 123, :bar => 123})],
+      [(record_3 = {:id => 3, :foo => 123, :bar => 123})],
+      [(record_4 = {:id => 4, :foo => 123, :bar => 456})],
+      [(record_5 = {:id => 5, :foo => 456, :bar => 123})],
+      [(record_6 = {:id => 6, :foo => 456, :bar => 456})],
+      [(record_7 = {:id => 7, :foo => 456, :bar => 456})]
+    )
+
+    observer.expects(:update).with(comp, record_1, record_2, 1)
+    observer.expects(:update).with(comp, record_1, record_3, 1)
+    observer.expects(:update).with(comp, record_2, record_3, 1)
+    observer.expects(:update).with(comp, record_6, record_7, 1)
+
+    comp.score_dataset(dataset)
+  end
+
+  test "score_dataset with different single field equality" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Compare.new([field_1], [field_2], :equal)
+    assert_equal :advanced, comp.type
+    observer = stub('observer', :update => nil)
+    comp.add_observer(observer)
+
+    dataset = stub('dataset')
+    dataset_1 = stub('dataset 1')
+    dataset.expects(:order).with(:foo).returns(dataset_1)
+    dataset_1.expects(:each).multiple_yields(
+      [(record_1 = {:id => 1, :foo => 123, :bar => 456})],
+      [(record_2 = {:id => 2, :foo => 456, :bar => 456})],
+      [(record_3 = {:id => 3, :foo => 456, :bar => 123})]
+    )
+
+    dataset_2 = stub('dataset 2')
+    dataset.expects(:order).with(:bar).returns(dataset_2)
+    dataset_2.expects(:each).multiple_yields(
+      [record_3],
+      [record_1],
+      [record_2]
+    )
+
+    observer.expects(:update).with(comp, record_1, record_3, 1)
+    observer.expects(:update).with(comp, record_2, record_1, 1)
+    observer.expects(:update).with(comp, record_2, record_2, 1)
+    observer.expects(:update).with(comp, record_3, record_1, 1)
+    observer.expects(:update).with(comp, record_3, record_2, 1)
+
+    comp.score_dataset(dataset)
   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)
+  test "requires equal size sets" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
     assert_raises do
-      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+      Compare.new([field_1, field_2], [], :greater_than_or_equal)
     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)
+  test "requires that sets have values with alike types" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Date })
     assert_raises do
-      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+      Compare.new([field_1], [field_2], :greater_than_or_equal)
     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)
+  test "requires valid operation" do
+    field_1 = stub('foo field', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('bar field', :name => :bar, :ruby_type => { :type => Integer })
     assert_raises do
-      Compare.new(meta_object_1, meta_object_2, meta_object_3)
+      Compare.new([field_1], [field_2], 'foo')
     end
   end
 end

data/test/unit/comparators/test_strcompare.rb

@@ -0,0 +1,45 @@
+require File.expand_path("../../test_comparators", __FILE__)
+
+class UnitTests::TestComparators::TestStrcompare < 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 Comparator" do
+    assert_equal Linkage::Comparator, Strcompare.superclass
+  end
+
+  test "requires string types" do
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => Integer })
+    assert_raises do
+      Strcompare.new(field_1, field_2, :jarowinkler)
+    end
+  end
+
+  test "requires valid operator" do
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => String })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => String })
+    assert_raises do
+      Strcompare.new(field_1, field_2, 'foo')
+    end
+  end
+
+  test "score for jarowinkler" do
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => String })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => String })
+    comp = Strcompare.new(field_1, field_2, :jarowinkler)
+    assert_equal 0.961, comp.score({:foo => 'martha'}, {:bar => 'marhta'})
+    assert_equal 0.840, comp.score({:foo => 'dwayne'}, {:bar => 'duane'})
+    assert_equal 0.813, comp.score({:foo => 'dixon'}, {:bar => 'dicksonx'})
+    assert_equal 0, comp.score({:foo => 'cat'}, {:bar => 'dog'})
+  end
+
+  test "registers itself" do
+    assert_equal Strcompare, Linkage::Comparator['strcompare']
+  end
+end

data/test/unit/comparators/test_within.rb

@@ -1,6 +1,6 @@
-require 'helper'
+require File.expand_path("../../test_comparators", __FILE__)
 
-class UnitTests::TestWithin < Test::Unit::TestCase
+class UnitTests::TestComparators::TestWithin < Test::Unit::TestCase
   def self.const_missing(name)
     if Linkage::Comparators.const_defined?(name)
       Linkage::Comparators.const_get(name)
@@ -9,24 +9,22 @@ class UnitTests::TestWithin < Test::Unit::TestCase
     end
   end
 
-  test "subclass of Binary" do
-    assert_equal Linkage::Comparators::Binary, Within.superclass
+  test "subclass of Comparator" do
+    assert_equal Linkage::Comparator, 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)
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => Integer })
     assert_nothing_raised do
-      Within.new(meta_object_1, meta_object_2, meta_object_3)
+      Within.new(field_1, field_2, 123)
     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)
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => Integer })
+    comp = Within.new(field_1, field_2, 123)
     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})
@@ -37,21 +35,11 @@ class UnitTests::TestWithin < Test::Unit::TestCase
     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)
+  test "requires that second argument has the same type as the first argument" do
+    field_1 = stub('field 1', :name => :foo, :ruby_type => { :type => Integer })
+    field_2 = stub('field 2', :name => :bar, :ruby_type => { :type => Date })
     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)
+      Within.new(field_1, field_2, 123)
     end
   end
 end

data/test/unit/match_sets/test_csv.rb

@@ -0,0 +1,78 @@
+require File.expand_path("../../test_match_sets", __FILE__)
+
+class UnitTests::TestMatchSets::TestCSV < Test::Unit::TestCase
+  test "open_for_writing" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    csv = stub('csv')
+    CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+    csv.expects(:<<).with(%w{id_1 id_2 score})
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing when already open" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    csv = stub('csv')
+    CSV.expects(:open).once.with('foo.csv', 'wb').returns(csv)
+    csv.expects(:<<).once.with(%w{id_1 id_2 score})
+    match_set.open_for_writing
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing when file exists" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    File.expects(:exist?).with('foo.csv').returns(true)
+    assert_raises(Linkage::ExistsError) do
+      match_set.open_for_writing
+    end
+  end
+
+  test "open_for_writing when file exists and forcing overwrite" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv', :overwrite => true)
+    File.stubs(:exist?).with('foo.csv').returns(true)
+    assert_nothing_raised do
+      csv = stub('csv')
+      CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+      csv.expects(:<<).with(%w{id_1 id_2 score})
+      match_set.open_for_writing
+    end
+  end
+
+  test "add_match when unopened raises exception" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    assert_raises { match_set.add_match(1, 2, 1) }
+  end
+
+  test "add_match" do
+    tempfile = Tempfile.new('linkage')
+    tempfile.close
+    match_set = Linkage::MatchSets::CSV.new(tempfile.path, :overwrite => true)
+    match_set.open_for_writing
+    match_set.add_match(1, 2, 1)
+    match_set.close
+
+    expected = "id_1,id_2,score\n1,2,1\n"
+    assert_equal expected, File.read(tempfile.path)
+  end
+
+  test "add_match removes extra decimals" do
+    match_set = Linkage::MatchSets::CSV.new('foo.csv')
+    csv = stub('csv')
+    CSV.stubs(:open).with('foo.csv', 'wb').returns(csv)
+    csv.stubs(:<<).with(%w{id_1 id_2 score})
+    match_set.open_for_writing
+
+    csv.expects(:<<).with do |(id_1, id_2, score)|
+      id_1 == 1 && id_2 == 2 && score.equal?(1)
+    end
+    match_set.add_match(1, 2, 1.0)
+
+    csv.expects(:<<).with do |(id_1, id_2, score)|
+      id_1 == 1 && id_2 == 2 && score.equal?(0)
+    end
+    match_set.add_match(1, 2, 0.0)
+  end
+
+  test "registers itself" do
+    assert_equal Linkage::MatchSets::CSV, Linkage::MatchSet['csv']
+  end
+end

data/test/unit/match_sets/test_database.rb

@@ -0,0 +1,63 @@
+require File.expand_path("../../test_match_sets", __FILE__)
+
+class UnitTests::TestMatchSets::TestDatabase < Test::Unit::TestCase
+  def setup
+    @dataset = stub('dataset')
+    @database = stub('database', :[] => @dataset)
+  end
+
+  test "open_for_writing for database with no matches table" do
+    match_set = Linkage::MatchSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing when already open" do
+    match_set = Linkage::MatchSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+    match_set.open_for_writing
+  end
+
+  test "open_for_writing when matches table already exists" do
+    match_set = Linkage::MatchSets::Database.new(@database)
+    @database.expects(:table_exists?).with(:matches).returns(true)
+    @database.expects(:create_table).with(:matches).never
+    assert_raises(Linkage::ExistsError) do
+      match_set.open_for_writing
+    end
+  end
+
+  test "open_for_writing when matches table already exists and in overwrite mode" do
+    match_set = Linkage::MatchSets::Database.new(@database, :overwrite => true)
+    @database.expects(:drop_table?).with(:matches)
+    @database.expects(:create_table).with(:matches)
+    @database.expects(:[]).with(:matches).returns(@dataset)
+    match_set.open_for_writing
+  end
+
+  test "add_match when unopened raises exception" do
+    match_set = Linkage::MatchSets::Database.new(@database)
+    assert_raises { match_set.add_match(1, 2, 1) }
+  end
+
+  test "add_match" do
+    match_set = Linkage::MatchSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:matches).returns(false)
+    @database.stubs(:create_table)
+    match_set.open_for_writing
+
+    @dataset.expects(:insert).with({
+      :id_1 => 1, :id_2 => 2, :score => 1
+    })
+    match_set.add_match(1, 2, 1)
+  end
+
+  test "registers itself" do
+    assert_equal Linkage::MatchSets::Database, Linkage::MatchSet['database']
+  end
+end