linkage 0.0.8 → 0.1.0.pre

data/test/unit/result_sets/test_csv.rb

@@ -0,0 +1,111 @@
+require File.expand_path("../../test_result_sets", __FILE__)
+
+class UnitTests::TestResultSets::TestCSV < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir('linkage')
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@tmpdir)
+  end
+
+  test "no directory option uses current directory" do
+    result_set = Linkage::ResultSets::CSV.new
+
+    expected_score_file = './scores.csv'
+    score_set = stub('score set')
+    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    expected_match_file = './matches.csv'
+    match_set = stub('match set')
+    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "directory option" do
+    opts = {
+      :dir => File.join(@tmpdir, 'foo')
+    }
+    result_set = Linkage::ResultSets::CSV.new(opts)
+    assert Dir.exist?(opts[:dir])
+
+    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
+    score_set = stub('score set')
+    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
+    match_set = stub('match set')
+    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "directory argument" do
+    dir = File.join(@tmpdir, 'foo')
+    result_set = Linkage::ResultSets::CSV.new(dir)
+    assert Dir.exist?(dir)
+
+    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
+    score_set = stub('score set')
+    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
+    match_set = stub('match set')
+    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "directory path is expanded" do
+    opts = {
+      :dir => "~/foo"
+    }
+    FileUtils.expects(:mkdir_p).with(File.expand_path("~/foo"))
+    result_set = Linkage::ResultSets::CSV.new(opts)
+  end
+
+  test "custom filenames" do
+    opts = {
+      :dir => File.join(@tmpdir, 'foo'),
+      :scores => {:filename => 'foo-scores.csv'},
+      :matches => {:filename => 'foo-matches.csv'}
+    }
+    result_set = Linkage::ResultSets::CSV.new(opts)
+    assert Dir.exist?(opts[:dir])
+
+    expected_score_file = File.join(@tmpdir, 'foo', 'foo-scores.csv')
+    score_set = stub('score set')
+    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    expected_match_file = File.join(@tmpdir, 'foo', 'foo-matches.csv')
+    match_set = stub('match set')
+    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "miscellaneous options" do
+    opts = {
+      :dir => File.join(@tmpdir, 'foo'),
+      :scores => {:foo => 'bar'},
+      :matches => {:baz => 'qux'}
+    }
+    result_set = Linkage::ResultSets::CSV.new(opts)
+    assert Dir.exist?(opts[:dir])
+
+    expected_score_file = File.join(@tmpdir, 'foo', 'scores.csv')
+    score_set = stub('score set')
+    Linkage::ScoreSets::CSV.expects(:new).with(expected_score_file, :foo => 'bar').returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    expected_match_file = File.join(@tmpdir, 'foo', 'matches.csv')
+    match_set = stub('match set')
+    Linkage::MatchSets::CSV.expects(:new).with(expected_match_file, :baz => 'qux').returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "registers itself" do
+    assert_same Linkage::ResultSets::CSV, Linkage::ResultSet['csv']
+  end
+end

data/test/unit/result_sets/test_database.rb

@@ -0,0 +1,68 @@
+require File.expand_path("../../test_result_sets", __FILE__)
+
+class UnitTests::TestResultSets::TestDatabase < Test::Unit::TestCase
+  test "with database object" do
+    database = stub('database')
+    database.stubs(:kind_of?).with(Sequel::Database).returns(true)
+    result_set = Linkage::ResultSets::Database.new(database)
+
+    score_set = stub('score set')
+    Linkage::ScoreSets::Database.expects(:new).with(database, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    match_set = stub('match set')
+    Linkage::MatchSets::Database.expects(:new).with(database, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "with uri string" do
+    database = stub('database')
+    Sequel.expects(:connect).with("foo://bar").returns(database)
+    result_set = Linkage::ResultSets::Database.new("foo://bar")
+
+    score_set = stub('score set')
+    Linkage::ScoreSets::Database.expects(:new).with(database, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    match_set = stub('match set')
+    Linkage::MatchSets::Database.expects(:new).with(database, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "with connect options" do
+    database = stub('database')
+    Sequel.expects(:connect).with(:foo => 'bar').returns(database)
+    result_set = Linkage::ResultSets::Database.new(:foo => 'bar')
+
+    score_set = stub('score set')
+    Linkage::ScoreSets::Database.expects(:new).with(database, {}).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    match_set = stub('match set')
+    Linkage::MatchSets::Database.expects(:new).with(database, {}).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "with database options and scores/matches options" do
+    opts = {
+      :foo => 'bar',
+      :scores => {:baz => 'qux'},
+      :matches => {:corge => 'grault'}
+    }
+    database = stub('database')
+    Sequel.expects(:connect).with(:foo => 'bar').returns(database)
+    result_set = Linkage::ResultSets::Database.new(opts)
+
+    score_set = stub('score set')
+    Linkage::ScoreSets::Database.expects(:new).with(database, opts[:scores]).returns(score_set)
+    assert_same score_set, result_set.score_set
+
+    match_set = stub('match set')
+    Linkage::MatchSets::Database.expects(:new).with(database, opts[:matches]).returns(match_set)
+    assert_same match_set, result_set.match_set
+  end
+
+  test "registers itself" do
+    assert_same Linkage::ResultSets::Database, Linkage::ResultSet['database']
+  end
+end

data/test/unit/score_sets/test_csv.rb

@@ -0,0 +1,151 @@
+require File.expand_path("../../test_score_sets", __FILE__)
+
+class UnitTests::TestScoreSets::TestCSV < Test::Unit::TestCase
+  test "open_for_writing" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    csv = stub('csv')
+    CSV.expects(:open).with('foo.csv', 'wb').returns(csv)
+    csv.expects(:<<).with(%w{comparator_id id_1 id_2 score})
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing when already open" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    csv = stub('csv')
+    CSV.expects(:open).once.with('foo.csv', 'wb').returns(csv)
+    csv.expects(:<<).once.with(%w{comparator_id id_1 id_2 score})
+    score_set.open_for_writing
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing when file exists" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.expects(:exist?).with('foo.csv').returns(true)
+    assert_raises(Linkage::ExistsError) do
+      score_set.open_for_writing
+    end
+  end
+
+  test "open_for_writing when file exists and forcing overwrite" do
+    score_set = Linkage::ScoreSets::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{comparator_id id_1 id_2 score})
+      score_set.open_for_writing
+    end
+  end
+
+  test "open_for_reading" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.stubs(:exist?).with('foo.csv').returns(true)
+    csv = stub('csv')
+    CSV.expects(:open).with('foo.csv', 'rb', {:headers => true}).returns(csv)
+    score_set.open_for_reading
+  end
+
+  test "open_for_reading when already open" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.stubs(:exist?).with('foo.csv').returns(true)
+    csv = stub('csv')
+    CSV.expects(:open).once.with('foo.csv', 'rb', {:headers => true}).returns(csv)
+    score_set.open_for_reading
+    score_set.open_for_reading
+  end
+
+  test "open_for_reading when file doesn't exist" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.expects(:exist?).with('foo.csv').returns(false)
+    assert_raises(Linkage::MissingError) do
+      score_set.open_for_reading
+    end
+  end
+
+  test "open_for_writing when in read mode raises exception" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.stubs(:exist?).with('foo.csv').returns(true)
+    csv = stub('csv')
+    CSV.stubs(:open).returns(csv)
+    score_set.open_for_reading
+    assert_raises(RuntimeError) { score_set.open_for_writing }
+  end
+
+  test "open_for_reading when in write mode raises exception" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    csv = stub('csv', :<< => nil)
+    CSV.stubs(:open).returns(csv)
+    score_set.open_for_writing
+    assert_raises(RuntimeError) { score_set.open_for_reading }
+  end
+
+  test "add_score when unopened raises exception" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    assert_raises { score_set.add_score(1, 1, 2, 1) }
+  end
+
+  test "add_score when in read mode raises exception" do
+    score_set = Linkage::ScoreSets::CSV.new('foo.csv')
+    File.stubs(:exist?).with('foo.csv').returns(true)
+    csv = stub('csv')
+    CSV.stubs(:open).returns(csv)
+    score_set.open_for_reading
+    assert_raises { score_set.add_score(1, 1, 2, 1) }
+  end
+
+  test "add_score" do
+    tempfile = Tempfile.new('linkage')
+    tempfile.close
+    score_set = Linkage::ScoreSets::CSV.new(tempfile.path, :overwrite => true)
+    score_set.open_for_writing
+    score_set.add_score(1, 1, 2, 1)
+    score_set.close
+
+    expected = "comparator_id,id_1,id_2,score\n1,1,2,1\n"
+    assert_equal expected, File.read(tempfile.path)
+  end
+
+  test "each_pair" do
+    tempfile = Tempfile.new('linkage')
+    tempfile.write(<<-EOF.gsub(/^\s*/, ""))
+      comparator_id,id_1,id_2,score
+      1,1,2,0.5
+      1,2,3,1
+      2,1,2,0
+      2,2,3,1
+      2,3,4,1
+      1,3,4,0
+      3,4,5,0
+    EOF
+    tempfile.close
+    score_set = Linkage::ScoreSets::CSV.new(tempfile.path)
+
+    pairs = []
+    score_set.each_pair { |*args| pairs << args }
+    assert_equal 4, pairs.length
+
+    pair_1 = pairs.detect { |pair| pair[0] == "1" && pair[1] == "2" }
+    assert pair_1
+    expected_1 = {1 => 0.5, 2 => 0}
+    assert_equal expected_1, pair_1[2]
+
+    pair_2 = pairs.detect { |pair| pair[0] == "2" && pair[1] == "3" }
+    assert pair_2
+    expected_2 = {1 => 1, 2 => 1}
+    assert_equal expected_2, pair_2[2]
+
+    pair_3 = pairs.detect { |pair| pair[0] == "3" && pair[1] == "4" }
+    assert pair_3
+    expected_3 = {1 => 0, 2 => 1}
+    assert_equal expected_3, pair_3[2]
+
+    pair_4 = pairs.detect { |pair| pair[0] == "4" && pair[1] == "5" }
+    assert pair_3
+    expected_4 = {3 => 0}
+    assert_equal expected_4, pair_4[2]
+  end
+
+  test "registers itself" do
+    assert_equal Linkage::ScoreSets::CSV, Linkage::ScoreSet['csv']
+  end
+end

data/test/unit/score_sets/test_database.rb

@@ -0,0 +1,149 @@
+require File.expand_path("../../test_score_sets", __FILE__)
+
+class UnitTests::TestScoreSets::TestDatabase < Test::Unit::TestCase
+  def setup
+    @dataset = stub('dataset')
+    @database = stub('database', :[] => @dataset)
+  end
+
+  test "open_for_writing for database with no scores table" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing when already open" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+    score_set.open_for_writing
+  end
+
+  test "open_for_writing when scores table already exists" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.expects(:table_exists?).with(:scores).returns(true)
+    @database.expects(:create_table).with(:scores).never
+    assert_raises(Linkage::ExistsError) do
+      score_set.open_for_writing
+    end
+  end
+
+  test "open_for_writing when scores table already exists and in overwrite mode" do
+    score_set = Linkage::ScoreSets::Database.new(@database, :overwrite => true)
+    @database.expects(:drop_table?).with(:scores)
+    @database.expects(:create_table).with(:scores)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_writing
+  end
+
+  test "open_for_reading" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(true)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_reading
+  end
+
+  test "open_for_reading when already open" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(true)
+    @database.expects(:[]).with(:scores).returns(@dataset)
+    score_set.open_for_reading
+    score_set.open_for_reading
+  end
+
+  test "open_for_reading when table is missing" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.expects(:table_exists?).with(:scores).returns(false)
+    @database.expects(:[]).with(:scores).returns(@dataset).never
+    assert_raises(Linkage::MissingError) do
+      score_set.open_for_reading
+    end
+  end
+
+  test "open_for_writing when in read mode raises exception" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(true)
+    score_set.open_for_reading
+    assert_raises(RuntimeError) { score_set.open_for_writing }
+  end
+
+  test "open_for_reading when in write mode raises exception" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.stubs(:create_table)
+    score_set.open_for_writing
+    assert_raises(RuntimeError) { score_set.open_for_reading }
+  end
+
+  test "add_score when unopened raises exception" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    assert_raises { score_set.add_score(1, 1, 2, 1) }
+  end
+
+  test "add_score when in read mode raises exception" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(true)
+    score_set.open_for_reading
+    assert_raises { score_set.add_score(1, 1, 2, 1) }
+  end
+
+  test "add_score" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(false)
+    @database.stubs(:create_table)
+    score_set.open_for_writing
+
+    @dataset.expects(:insert).with({
+      :comparator_id => 1, :id_1 => 1, :id_2 => 2, :score => 1
+    })
+    score_set.add_score(1, 1, 2, 1)
+  end
+
+  test "each_pair" do
+    score_set = Linkage::ScoreSets::Database.new(@database)
+    @database.stubs(:table_exists?).with(:scores).returns(true)
+    score_set.open_for_reading
+
+    @dataset.expects(:order).with(:id_1, :id_2, :comparator_id).returns(@dataset)
+    @dataset.expects(:each).multiple_yields(
+      [{:comparator_id => 1, :id_1 => '1', :id_2 => '2', :score => 0.5}],
+      [{:comparator_id => 2, :id_1 => '1', :id_2 => '2', :score => 0}],
+      [{:comparator_id => 1, :id_1 => '2', :id_2 => '3', :score => 1}],
+      [{:comparator_id => 2, :id_1 => '2', :id_2 => '3', :score => 1}],
+      [{:comparator_id => 1, :id_1 => '3', :id_2 => '4', :score => 0}],
+      [{:comparator_id => 2, :id_1 => '3', :id_2 => '4', :score => 1}],
+      [{:comparator_id => 3, :id_1 => '4', :id_2 => '5', :score => 0}]
+    )
+    pairs = []
+    score_set.each_pair { |*args| pairs << args }
+    assert_equal 4, pairs.length
+
+    pair_1 = pairs.detect { |pair| pair[0] == "1" && pair[1] == "2" }
+    assert pair_1
+    expected_1 = {1 => 0.5, 2 => 0}
+    assert_equal expected_1, pair_1[2]
+
+    pair_2 = pairs.detect { |pair| pair[0] == "2" && pair[1] == "3" }
+    assert pair_2
+    expected_2 = {1 => 1, 2 => 1}
+    assert_equal expected_2, pair_2[2]
+
+    pair_3 = pairs.detect { |pair| pair[0] == "3" && pair[1] == "4" }
+    assert pair_3
+    expected_3 = {1 => 0, 2 => 1}
+    assert_equal expected_3, pair_3[2]
+
+    pair_4 = pairs.detect { |pair| pair[0] == "4" && pair[1] == "5" }
+    assert pair_3
+    expected_4 = {3 => 0}
+    assert_equal expected_4, pair_4[2]
+  end
+
+  test "registers itself" do
+    assert_equal Linkage::ScoreSets::Database, Linkage::ScoreSet['database']
+  end
+end

data/test/unit/test_comparator.rb

@@ -11,114 +11,77 @@ class UnitTests::TestComparator < Test::Unit::TestCase
     super
   end
 
-  test "comparator_name raises error in base class" do
-    assert_raises(NotImplementedError) { Linkage::Comparator.comparator_name }
-  end
-
-  test "registering subclass requires comparator_name" do
-    klass = Class.new(Linkage::Comparator)
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  test "default subclass has type of simple" do
+    klass = new_comparator
+    instance = klass.new
+    assert_equal :simple, instance.type
   end
 
   test "getting a registered subclass" do
-    klass = new_comparator('foo', [[String]], 0..1)
-    Linkage::Comparator.register(klass)
+    klass = new_comparator
+    Linkage::Comparator.register('foo', klass)
     assert_equal klass, Linkage::Comparator['foo']
   end
 
-  test "parameters raises error in base class" do
-    assert_raises(NotImplementedError) { Linkage::Comparator.parameters }
-  end
-
-  test "subclasses required to define parameters class method" do
-    klass = new_comparator('foo')
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
-  end
-
-  test "subclasses required to define at least one parameter" do
-    klass = new_comparator('foo', [])
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
-  end
+  test "registering subclass with advanced scoring methods" do
+    klass = new_comparator do
+      remove_method :score
 
-  test "subclasses required to define score_range class method" do
-    klass = new_comparator('foo', [[String]])
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
-  end
+      def score_datasets(dataset_1, dataset_2)
+      end
 
-  test "score_range class should be a Range of two numbers" do
-    klass = new_comparator('foo', [[String]], "foo".."bar")
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+      def score_dataset(dataset)
+      end
+    end
+    assert_nothing_raised { Linkage::Comparator.register('foo', klass) }
   end
 
-  test "subclasses required to define score method" do
-    klass = new_comparator('foo', [[String]]) do
+  test "subclasses required to define either simple or advanced scoring methods" do
+    klass = new_comparator do
       remove_method :score
     end
-    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
-  end
-
-  test "comparator with one valid argument" do
-    klass = new_comparator('foo', [[String]])
-    meta_object = stub('meta object', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
-    f = klass.new(meta_object)
-  end
-
-  test "comparator with one invalid argument" do
-    klass = new_comparator('foo', [[String]])
-    meta_object = stub('meta_object', :ruby_type => { :type => Fixnum }, :static? => false)
-    assert_raises(TypeError) { klass.new(meta_object) }
-  end
+    assert_raises(ArgumentError) { Linkage::Comparator.register('foo', klass) }
 
-  test "comparator with too few arguments" do
-    klass = new_comparator('foo', [[String]])
-    assert_raises(ArgumentError) { klass.new }
-  end
+    klass = new_comparator do
+      remove_method :score
 
-  test "comparator with too many arguments" do
-    klass = new_comparator('foo', [[String]])
-    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => false)
-    assert_raises(ArgumentError) { klass.new(meta_object, meta_object) }
+      def score_datasets(dataset_1, dataset_2)
+      end
+    end
+    assert_raises(ArgumentError) { Linkage::Comparator.register('foo', klass) }
   end
 
-  test "requiring argument to be non-static" do
-    klass = new_comparator('foo', [[String, :static => false]])
-    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => true)
-    assert_raise_message("argument 1 was expected to not be static") do
-      klass.new(meta_object)
+  test "score raises NotImplementedError" do
+    comparator = Linkage::Comparator.new
+    assert_raises(NotImplementedError) do
+      comparator.score(stub('record 1'), stub('record 2'))
     end
   end
 
-  test "requiring argument to be static" do
-    klass = new_comparator('foo', [[String, :static => true]])
-    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => false)
-    assert_raise_message("argument 1 was expected to be static") do
-      klass.new(meta_object)
+  test "score_datasets raises NotImplementedError" do
+    comparator = Linkage::Comparator.new
+    assert_raises(NotImplementedError) do
+      comparator.score_datasets(stub('dataset 1'), stub('dataset 2'))
     end
   end
 
-  test "special :any parameter" do
-    klass = new_comparator('foo', [[:any]])
-    meta_object_1 = stub('meta_object', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
-    meta_object_2 = stub('meta_object', :side => :rhs, :ruby_type => { :type => Fixnum }, :static? => false)
-    assert_nothing_raised do
-      klass.new(meta_object_1)
-      klass.new(meta_object_2)
+  test "score_dataset raises NotImplementedError" do
+    comparator = Linkage::Comparator.new
+    assert_raises(NotImplementedError) do
+      comparator.score_dataset(stub('dataset'))
     end
   end
 
-  test "lhs_args" do
-    klass = new_comparator('foo', [[String], [String]])
-    meta_object_1 = stub('meta object 1', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
-    meta_object_2 = stub('meta object 2', :side => :rhs, :ruby_type => { :type => String }, :static? => false)
-    obj = klass.new(meta_object_1, meta_object_2)
-    assert_equal [meta_object_1], obj.lhs_args
-  end
+  test "score_and_notify" do
+    klass = new_comparator
+    instance = klass.new
+
+    observer = stub('observer', :update => nil)
+    instance.add_observer(observer)
 
-  test "rhs_args" do
-    klass = new_comparator('foo', [[String], [String]])
-    meta_object_1 = stub('meta object 1', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
-    meta_object_2 = stub('meta object 2', :side => :rhs, :ruby_type => { :type => String }, :static? => false)
-    obj = klass.new(meta_object_1, meta_object_2)
-    assert_equal [meta_object_2], obj.rhs_args
+    record_1 = stub('record 1')
+    record_2 = stub('record 2')
+    observer.expects(:update).with(instance, record_1, record_2, 1)
+    instance.score_and_notify(record_1, record_2)
   end
 end

data/test/unit/test_comparators.rb

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