linkage 0.0.8 → 0.1.0.pre

data/test/unit/test_configuration.rb

@@ -1,172 +1,126 @@
 require 'helper'
 
 class UnitTests::TestConfiguration < Test::Unit::TestCase
-  test "result_set" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    c = Linkage::Configuration.new(dataset_1, dataset_2)
-
-    result_set = stub('result set')
-    Linkage::ResultSet.expects(:new).with(c).returns(result_set)
-    assert_equal result_set, c.result_set
+  def setup
+    @pk_1 = stub('primary key 1', :name => :id)
+    @field_1 = stub('field 1')
+    @field_set_1 = stub('field set 1', :primary_key => @pk_1, :[] => @field_1)
+    @dataset_1 = stub('dataset 1', :field_set => @field_set_1)
+    @pk_2 = stub('primary key 2', :name => :id)
+    @field_2 = stub('field 2')
+    @field_set_2 = stub('field set 2', :primary_key => @pk_2, :[] => @field_2)
+    @dataset_2 = stub('dataset 2', :field_set => @field_set_2)
+    @score_set = stub('score set')
+    @match_set = stub('match set')
+    @result_set = stub('result set', :score_set => @score_set, :match_set => @match_set)
+    @compare = stub('compare')
+    Linkage::Comparators::Compare.stubs(:new).returns(@compare)
   end
 
-  test "groups_table_needed? is false if there are no simple expectations" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    assert !conf.groups_table_needed?
+  test "init with single dataset and result set" do
+    config = Linkage::Configuration.new(@dataset_1, @result_set)
+    assert_equal @dataset_1, config.dataset_1
+    assert_nil config.dataset_2
+    assert_equal @result_set, config.result_set
   end
 
-  test "groups_table_needed? is true if there are any simple expectations" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    exp = stub('simple expectation', :decollation_needed? => false)
-    conf.add_simple_expectation(exp)
-    assert conf.groups_table_needed?
+  test "init with two datasets and result set" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    assert_equal @dataset_1, config.dataset_1
+    assert_equal @dataset_2, config.dataset_2
+    assert_equal @result_set, config.result_set
   end
 
-  test "scores_table_needed? is false if there are no exhaustive expectations" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    assert !conf.scores_table_needed?
+  test "adding comparator with set arguments and two datasets" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+
+    @field_set_1.expects(:[]).with(:foo).returns(@field_1)
+    @field_set_2.expects(:[]).with(:foo).returns(@field_2)
+    Linkage::Comparators::Compare.expects(:new).with([@field_1], [@field_2], :equal).returns(@compare)
+    config.compare([:foo], [:foo], :equal)
+    assert_equal @compare, config.comparators[0]
   end
 
-  test "scores_table_needed? is true if there are any exhaustive expectations" do
-    dataset_1 = stub('dataset')
-    dataset_2 = stub('dataset')
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    exp = stub('exhaustive expectation')
-    conf.add_exhaustive_expectation(exp)
-    assert conf.scores_table_needed?
+  test "adding comparator with set arguments and one datasets" do
+    config = Linkage::Configuration.new(@dataset_1, @result_set)
+
+    @field_set_1.expects(:[]).with(:foo).returns(@field_1)
+    @field_set_1.expects(:[]).with(:bar).returns(@field_2)
+    Linkage::Comparators::Compare.expects(:new).with([@field_1], [@field_2], :equal).returns(@compare)
+    config.compare([:foo], [:bar], :equal)
+    assert_equal @compare, config.comparators[0]
   end
 
-  test "scores_table_schema" do
-    dataset_1 = stub('dataset 1', {
-      :field_set => stub('field set 1', {
-        :primary_key => stub('primary key 1', {
-          :ruby_type => {:type => Integer}
-        })
-      })
-    })
-    dataset_2 = stub('dataset 2', {
-      :field_set => stub('field set 2', {
-        :primary_key => stub('primary key 2', {
-          :ruby_type => {:type => String, :opts => {:size => 10}}
-        })
-      })
-    })
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    exp_1 = stub('exhaustive expectation 1')
-    exp_2 = stub('exhaustive expectation 2')
-    conf.add_exhaustive_expectation(exp_1)
-    conf.add_exhaustive_expectation(exp_2)
-
-    expected = [
-      [:id, Integer, {:primary_key => true}],
-      [:comparator_id, Integer, {}],
-      [:record_1_id, Integer, {}],
-      [:record_2_id, String, {:size => 10}],
-      [:score, Integer, {}],
-    ]
-    assert_equal expected, conf.scores_table_schema
+  test "adding comparator with scalar arguments and two datasets" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+
+    @field_set_1.expects(:[]).with(:foo).returns(@field_1)
+    @field_set_2.expects(:[]).with(:foo).returns(@field_2)
+    within = stub('within')
+    Linkage::Comparators::Within.expects(:new).with(@field_1, @field_2, 5).returns(within)
+    config.within(:foo, :foo, 5)
+    assert_equal within, config.comparators[0]
   end
 
-  test "datasets_with_applied_exhaustive_expectations" do
-    dataset_1 = stub('dataset 1', {
-      :field_set => stub('field set 1', {
-        :primary_key => stub('primary key 1', {
-          :to_expr => :foo_id
-        })
-      })
-    })
-    dataset_2 = stub('dataset 2', {
-      :field_set => stub('field set 2', {
-        :primary_key => stub('primary key 2', {
-          :to_expr => :bar_id
-        })
-      })
-    })
-    dataset_1a = stub('dataset 1a')
-    dataset_2a = stub('dataset 2a')
-    dataset_1b = stub('dataset 1b')
-    dataset_2b = stub('dataset 2b')
-    dataset_1c = stub('dataset 1c')
-    dataset_2c = stub('dataset 2c')
-    exp_1 = stub('exhaustive expectation 1')
-    exp_2 = stub('exhaustive expectation 2')
-
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-    conf.add_exhaustive_expectation(exp_1)
-    conf.add_exhaustive_expectation(exp_2)
-
-    dataset_1.expects(:select).with(:foo_id).returns(dataset_1a)
-    dataset_2.expects(:select).with(:bar_id).returns(dataset_2a)
-    exp_1.expects(:apply_to).with(dataset_1a, :lhs).returns(dataset_1b)
-    exp_1.expects(:apply_to).with(dataset_2a, :rhs).returns(dataset_2b)
-    exp_2.expects(:apply_to).with(dataset_1b, :lhs).returns(dataset_1c)
-    exp_2.expects(:apply_to).with(dataset_2b, :rhs).returns(dataset_2c)
-
-    assert_equal [dataset_1c, dataset_2c], conf.datasets_with_applied_exhaustive_expectations
+  test "score_recorder with two datasets" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    config.compare([:foo], [:foo], :equal)
+
+    @field_set_1.expects(:primary_key).returns(@pk_1)
+    @field_set_2.expects(:primary_key).returns(@pk_2)
+    @pk_1.expects(:name).returns(:id_1)
+    @pk_2.expects(:name).returns(:id_2)
+    score_recorder = stub('recorder')
+    Linkage::ScoreRecorder.expects(:new).with([@compare], @score_set, [:id_1, :id_2]).returns(score_recorder)
+    assert_same score_recorder, config.score_recorder
   end
 
-  test "matches_table_schema" do
-    dataset_1 = stub('dataset 1', {
-      :field_set => stub('field set 1', {
-        :primary_key => stub('primary key 1', {
-          :ruby_type => {:type => Integer}
-        })
-      })
-    })
-    dataset_2 = stub('dataset 2', {
-      :field_set => stub('field set 2', {
-        :primary_key => stub('primary key 2', {
-          :ruby_type => {:type => String, :opts => {:size => 10}}
-        })
-      })
-    })
-    conf = Linkage::Configuration.new(dataset_1, dataset_2)
-
-    expected = [
-      [:id, Integer, {:primary_key => true}],
-      [:record_1_id, Integer, {}],
-      [:record_2_id, String, {:size => 10}],
-      [:total_score, Integer, {}],
-    ]
-    assert_equal expected, conf.matches_table_schema
+  test "score_recorder with one dataset" do
+    config = Linkage::Configuration.new(@dataset_1, @result_set)
+    config.compare([:foo], [:bar], :equal)
+
+    @field_set_1.expects(:primary_key).returns(@pk_1)
+    @pk_1.expects(:name).returns(:id_1)
+    score_recorder = stub('score recorder')
+    Linkage::ScoreRecorder.expects(:new).with([@compare], @score_set, [:id_1, :id_1]).returns(score_recorder)
+    assert_same score_recorder, config.score_recorder
   end
 
-  test "change groups table name from default" do
-    dataset = stub('dataset')
-    conf = Linkage::Configuration.new(dataset, dataset)
-    assert_equal :groups, conf.groups_table_name
-    conf.groups_table_name = :foo_groups
-    assert_equal :foo_groups, conf.groups_table_name
+  test "default matcher" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    config.compare([:foo], [:bar], :equal)
+
+    matcher = stub('matcher')
+    Linkage::Matcher.expects(:new).with([@compare], @score_set, :mean, 0.5).returns(matcher)
+    assert_equal matcher, config.matcher
   end
 
-  test "change original groups table name from default" do
-    dataset = stub('dataset')
-    conf = Linkage::Configuration.new(dataset, dataset)
-    assert_equal :original_groups, conf.original_groups_table_name
-    conf.original_groups_table_name = :foo_original_groups
-    assert_equal :foo_original_groups, conf.original_groups_table_name
+  test "matcher with explicit algorithm" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    config.compare([:foo], [:bar], :equal)
+    config.algorithm = :foo
+
+    matcher = stub('matcher')
+    Linkage::Matcher.expects(:new).with([@compare], @score_set, :foo, 0.5).returns(matcher)
+    assert_equal matcher, config.matcher
   end
 
-  test "change scores table name from default" do
-    dataset = stub('dataset')
-    conf = Linkage::Configuration.new(dataset, dataset)
-    assert_equal :scores, conf.scores_table_name
-    conf.scores_table_name = :foo_scores
-    assert_equal :foo_scores, conf.scores_table_name
+  test "matcher with explicit threshold" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+    config.compare([:foo], [:bar], :equal)
+    config.threshold = 0.9
+
+    matcher = stub('matcher')
+    Linkage::Matcher.expects(:new).with([@compare], @score_set, :mean, 0.9).returns(matcher)
+    assert_equal matcher, config.matcher
   end
 
-  test "change matches table name from default" do
-    dataset = stub('dataset')
-    conf = Linkage::Configuration.new(dataset, dataset)
-    assert_equal :matches, conf.matches_table_name
-    conf.matches_table_name = :foo_matches
-    assert_equal :foo_matches, conf.matches_table_name
+  test "match_recorder" do
+    config = Linkage::Configuration.new(@dataset_1, @dataset_2, @result_set)
+
+    matcher = stub('matcher')
+    match_recorder = stub('match recorder')
+    Linkage::MatchRecorder.expects(:new).with(matcher, @match_set).returns(match_recorder)
+    assert_equal match_recorder, config.match_recorder(matcher)
   end
 end

data/test/unit/test_dataset.rb

@@ -8,36 +8,45 @@ class UnitTests::TestDataset < Test::Unit::TestCase
       [:first_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}],
       [:last_name, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :ruby_default=>nil}]
     ]
+
     @dataset = stub('Sequel dataset', :first_source_table => :foo)
-    @database = stub('database', :schema => @schema, :[] => @dataset, :extend => nil)
+    @dataset.responds_like_instance_of(Sequel::Dataset)
+    @dataset.stubs(:kind_of?).with(Sequel::Dataset).returns(true)
+
+    @database = stub('database', :schema => @schema, :[] => @dataset)
+    @database.responds_like_instance_of(Sequel::Database)
+    @database.stubs(:kind_of?).with(Sequel::Database).returns(true)
     @dataset.stubs(:db).returns(@database)
     Sequel.stubs(:connect).returns(@database)
+
     @field_set = stub("field set")
     Linkage::FieldSet.stubs(:new).returns(@field_set)
   end
 
   test "initialize with uri and table name" do
     Sequel.expects(:connect).with('foo:/bar', {:foo => 'bar'}).returns(@database)
-    @database.expects(:extend).with(Sequel::Collation)
     @database.expects(:[]).with(:foo).returns(@dataset)
     Linkage::FieldSet.expects(:new).with(kind_of(Linkage::Dataset)).returns(@field_set)
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    assert_equal @field_set, ds.field_set
   end
 
   test "initialize with sequel dataset" do
-    Linkage::Dataset.new(@dataset)
-  end
-
-  test "extend Sequel::Collation when initializing with sequel dataset" do
-    @database.stubs(:kind_of?).with(Sequel::Collation).returns(false)
-    @database.expects(:extend).with(Sequel::Collation)
+    @dataset.expects(:first_source_table).returns(:foo)
+    @dataset.expects(:db).returns(@database)
+    Linkage::FieldSet.expects(:new).with(kind_of(Linkage::Dataset)).returns(@field_set)
     ds = Linkage::Dataset.new(@dataset)
+    assert_equal :foo, ds.table_name
+    assert_equal @field_set, ds.field_set
   end
 
-  test "don't extend already extended database" do
-    @database.stubs(:kind_of?).with(Sequel::Collation).returns(true)
-    @database.expects(:extend).with(Sequel::Collation).never
-    ds = Linkage::Dataset.new(@dataset)
+  test "initialize with sequel database and table name" do
+    Sequel.unstub(:connect)
+    Sequel.expects(:connect).never
+    @database.expects(:[]).with(:foo).returns(@dataset)
+    Linkage::FieldSet.expects(:new).with(kind_of(Linkage::Dataset)).returns(@field_set)
+    ds = Linkage::Dataset.new(@database, "foo")
+    assert_equal @field_set, ds.field_set
   end
 
   test "table_name" do
@@ -69,72 +78,42 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert_equal :foo, ds.database_type
   end
 
-  test "set group_match" do
-    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).returns(@dataset)
-    meta_object = stub_instance(Linkage::MetaObject)
-    ds_2 = ds_1.group_match(meta_object)
-    assert_not_same ds_1, ds_2
-    assert_not_equal ds_1.instance_variable_get(:@linkage_options),
-      ds_2.instance_variable_get(:@linkage_options)
-  end
-
-  test "subsequent group_match replaces old options" do
-    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).at_least_once.returns(@dataset)
-    meta_object_1 = stub_instance(Linkage::MetaObject)
-    ds_2 = ds_1.group_match(meta_object_1)
-    assert_equal([{:meta_object => meta_object_1}], ds_2.linkage_options[:group_match])
-
-    meta_object_2 = stub_instance(Linkage::MetaObject)
-    ds_3 = ds_2.group_match(meta_object_2)
-    assert_equal([{:meta_object => meta_object_2}], ds_3.linkage_options[:group_match])
-  end
-
-  test "group_match_more appends to group_match options" do
-    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).at_least_once.returns(@dataset)
-    meta_object_1 = stub_instance(Linkage::MetaObject)
-    ds_2 = ds_1.group_match(meta_object_1)
-    assert_equal([{:meta_object => meta_object_1}], ds_2.linkage_options[:group_match])
-
-    meta_object_2 = stub_instance(Linkage::MetaObject)
-    ds_3 = ds_2.group_match_more(meta_object_2)
-    assert_equal([{:meta_object => meta_object_1}, {:meta_object => meta_object_2}], ds_3.linkage_options[:group_match])
-  end
-
-  test "group_by_matches" do
+  test "primary key" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-
-    @dataset.expects(:clone).returns(@dataset)
-    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
-    ds = ds.group_match(meta_object)
-    @dataset.expects(:group).with(:foo).returns(@dataset)
-
-    ds.group_by_matches
+    pk = stub('primary key field')
+    @field_set.expects(:primary_key).returns(pk)
+    assert_equal pk, ds.primary_key
   end
 
-  test "dataset_for_group" do
-    ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).returns(@dataset)
-    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
-    ds = ds.group_match({:meta_object => meta_object, :alias => :foo_bar})
-
-    group = stub("group", :values => {:foo_bar => 'baz'})
-    filtered_dataset = stub('filtered dataset')
-    @dataset.expects(:filter).with(:foo => 'baz').returns(filtered_dataset)
-    assert_equal filtered_dataset, ds.dataset_for_group(group)
+  test "link_with other" do
+    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    ds_2 = Linkage::Dataset.new('foo:/bar', "bar", {:foo => 'bar'})
+    result_set = stub('result set')
+    conf = stub('configuration')
+    Linkage::Configuration.expects(:new).with(ds_1, ds_2, result_set).returns(conf)
+    actual = ds_1.link_with(ds_2, result_set) do |arg|
+      assert_equal conf, arg
+    end
+    assert_equal actual, conf
   end
 
-  test "dataset_for_group without aliases" do
+  test "link_with self" do
     ds = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
-    @dataset.expects(:clone).returns(@dataset)
-    meta_object = stub_instance(Linkage::MetaObject, :to_expr => :foo)
-    ds = ds.group_match(meta_object)
-
-    group = stub("group", :values => {:foo => 'baz'})
-    filtered_dataset = stub('filtered dataset')
-    @dataset.expects(:filter).with(:foo => 'baz').returns(filtered_dataset)
-    assert_equal filtered_dataset, ds.dataset_for_group(group)
+    result_set = stub('result set')
+    conf = stub('configuration')
+    Linkage::Configuration.expects(:new).with(ds, nil, result_set).returns(conf)
+    actual = ds.link_with(ds, result_set) do |arg|
+      assert_equal conf, arg
+    end
+    assert_equal actual, conf
+  end
+
+  test "delegating" do
+    dataset_2 = Sequel::Dataset.allocate
+    @dataset.expects(:filter).with(:foo => 123).returns(dataset_2)
+    ds_1 = Linkage::Dataset.new('foo:/bar', "foo", {:foo => 'bar'})
+    ds_2 = ds_1.filter(:foo => 123)
+    assert_kind_of Linkage::Dataset, ds_2
+    assert_same dataset_2, ds_2.obj
   end
 end

data/test/unit/test_field.rb

@@ -1,74 +1,23 @@
 require 'helper'
 
 class UnitTests::TestField < Test::Unit::TestCase
-  test "subclass of data" do
-    assert_equal Linkage::Data, Linkage::Field.superclass
-  end
-
   test "initialize with schema info" do
-    dataset = stub('dataset')
     schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
-    field = Linkage::Field.new(dataset, :id, schema)
+    field = Linkage::Field.new(:id, schema)
     assert_equal :id, field.name
     assert_equal schema, field.schema
-    assert_equal dataset, field.dataset
-  end
-
-  test "static? is always false" do
-    dataset = stub('dataset')
-    schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
-    field = Linkage::Field.new(dataset, :id, schema)
-    assert !field.static?
   end
 
   test "ruby_type for integer" do
-    dataset = stub('dataset')
-    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert_equal({:type => Integer}, field.ruby_type)
   end
 
   test "primary_key? returns true if primary key" do
-    dataset = stub('dataset')
-    field_1 = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert field_1.primary_key?
 
-    field_2 = Linkage::Field.new(dataset, :foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert !field_2.primary_key?
   end
-
-  test "to_expr returns name" do
-    dataset = stub('dataset')
-    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    assert_equal :id, field.to_expr
-  end
-
-  test "to_expr ignores adapter argument" do
-    dataset = stub('dataset')
-    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    assert_equal :id, field.to_expr(:foo)
-  end
-
-  test "collation" do
-    dataset = stub('dataset')
-    field = Linkage::Field.new(dataset, :foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :collation=>"latin1_general_cs", :ruby_default=>nil})
-    assert_equal "latin1_general_cs", field.collation
-    assert_equal "latin1_general_cs", field.ruby_type[:opts][:collate]
-  end
-
-  test "initialize MergeField with ruby type" do
-    info = {:type => Integer}
-    field = Linkage::MergeField.new(:id, info)
-    assert_equal :id, field.name
-    assert_equal info, field.ruby_type
-    assert_nil field.schema
-    assert_nil field.dataset
-  end
-
-  test "MergeField#database_type accessor" do
-    field_1 = Linkage::MergeField.new(:id, {:type => Integer})
-    assert_nil field_1.database_type
-
-    field_2 = Linkage::MergeField.new(:id, {:type => Integer}, :mysql)
-    assert_equal :mysql, field_2.database_type
-  end
 end

data/test/unit/test_field_set.rb

@@ -20,9 +20,9 @@ class UnitTests::TestFieldSet < Test::Unit::TestCase
     field_1 = stub('id field')
     field_2 = stub('first_name field')
     field_3 = stub('last_name field')
-    Linkage::Field.expects(:new).with(dataset, :id, @schema[:id]).returns(field_1)
-    Linkage::Field.expects(:new).with(dataset, :first_name, @schema[:first_name]).returns(field_2)
-    Linkage::Field.expects(:new).with(dataset, :last_name, @schema[:last_name]).returns(field_3)
+    Linkage::Field.expects(:new).with(:id, @schema[:id]).returns(field_1)
+    Linkage::Field.expects(:new).with(:first_name, @schema[:first_name]).returns(field_2)
+    Linkage::Field.expects(:new).with(:last_name, @schema[:last_name]).returns(field_3)
 
     fs = Linkage::FieldSet.new(dataset)
     assert_equal field_1, fs.primary_key
@@ -37,9 +37,9 @@ class UnitTests::TestFieldSet < Test::Unit::TestCase
     field_1 = stub('id field')
     field_2 = stub('first_name field')
     field_3 = stub('last_name field')
-    Linkage::Field.stubs(:new).with(dataset, :id, @schema[:id]).returns(field_1)
-    Linkage::Field.stubs(:new).with(dataset, :first_name, @schema[:first_name]).returns(field_2)
-    Linkage::Field.stubs(:new).with(dataset, :last_name, @schema[:last_name]).returns(field_3)
+    Linkage::Field.stubs(:new).with(:id, @schema[:id]).returns(field_1)
+    Linkage::Field.stubs(:new).with(:first_name, @schema[:first_name]).returns(field_2)
+    Linkage::Field.stubs(:new).with(:last_name, @schema[:last_name]).returns(field_3)
 
     fs = Linkage::FieldSet.new(dataset)
     assert_equal field_1, fs.primary_key

data/test/unit/test_match_recorder.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class UnitTests::TestMatchRecorder < Test::Unit::TestCase
+  def setup
+    @match_set = stub('match set')
+    @matcher = stub('matcher')
+  end
+
+  test "recording events from a matcher" do
+    match_recorder = Linkage::MatchRecorder.new(@matcher, @match_set)
+
+    @matcher.expects(:add_observer).with(match_recorder)
+    @match_set.expects(:open_for_writing)
+    match_recorder.start
+
+    @match_set.expects(:add_match).with(123, 456, 1)
+    match_recorder.update(123, 456, 1)
+
+    @matcher.expects(:delete_observer).with(match_recorder)
+    @match_set.expects(:close)
+    match_recorder.stop
+  end
+end

data/test/unit/test_match_set.rb

@@ -0,0 +1,23 @@
+require 'helper'
+
+class TestMatchSet < Test::Unit::TestCase
+  test "add_match raises NotImplementedError" do
+    match_set = Linkage::MatchSet.new
+    assert_raises(NotImplementedError) do
+      match_set.add_match('foo', 'bar', 'baz')
+    end
+  end
+
+  test "getting a registered class" do
+    klass = new_match_set
+    Linkage::MatchSet.register('foo', klass)
+    assert_equal klass, Linkage::MatchSet['foo']
+  end
+
+  test "registered classes required to define add_match" do
+    klass = new_match_set do
+      remove_method :add_match
+    end
+    assert_raises(ArgumentError) { Linkage::MatchSet.register('foo', klass) }
+  end
+end

data/test/unit/test_match_sets.rb

@@ -0,0 +1,4 @@
+require 'helper'
+
+module UnitTests::TestMatchSets
+end

data/test/unit/test_matcher.rb

@@ -0,0 +1,44 @@
+require 'helper'
+
+class UnitTests::TestMatcher < Test::Unit::TestCase
+  def setup
+    @score_set = stub('score set')
+    @comparators = [stub('comparator 1'), stub('comparator 2'), stub('comparator 3')]
+  end
+
+  test "finding matches with mean and threshold" do
+    matcher = Linkage::Matcher.new(@comparators, @score_set, :mean, 0.5)
+    observer = stub('observer')
+    observer.expects(:update).with(3, 4, 2.0 / 3)
+    observer.expects(:update).with(4, 5, 1.0)
+    matcher.add_observer(observer)
+
+    pairs = [
+      [1, 2, {1 => 1, 2 => 0, 3 => 0}],
+      [2, 3, {1 => 0, 2 => 0, 3 => 0}],
+      [3, 4, {1 => 0, 2 => 1, 3 => 1}],
+      [4, 5, {1 => 1, 2 => 1, 3 => 1}]
+    ]
+    @score_set.expects(:each_pair).multiple_yields(*pairs)
+
+    matcher.run
+  end
+
+  test "finding matches with mean and threshold with missing scores" do
+    matcher = Linkage::Matcher.new(@comparators, @score_set, :mean, 0.5)
+    observer = stub('observer')
+    observer.expects(:update).with(3, 4, 2.0 / 3)
+    observer.expects(:update).with(4, 5, 1.0)
+    matcher.add_observer(observer)
+
+    pairs = [
+      [1, 2, {1 => 1, 3 => 0}],
+      [2, 3, {1 => 0, 2 => 0, 3 => 0}],
+      [3, 4, {2 => 1, 3 => 1}],
+      [4, 5, {1 => 1, 2 => 1, 3 => 1}]
+    ]
+    @score_set.expects(:each_pair).multiple_yields(*pairs)
+
+    matcher.run
+  end
+end