linkage 0.0.8 → 0.1.0.pre

data/test/unit/test_result_set.rb

@@ -1,236 +1,37 @@
 require 'helper'
 
 class TestResultSet < Test::Unit::TestCase
-  def setup
-    @config = stub('configuration', {
-      :results_uri => 'foo://bar',
-      :results_uri_options => {:blah => 'junk'},
-      :decollation_needed? => true,
-      :groups_table_name => :groups,
-      :original_groups_table_name => :original_groups,
-      :scores_table_name => :scores,
-      :matches_table_name => :matches
-    })
-    @database = stub('database')
-    Sequel.stubs(:connect).with('foo://bar', :blah => 'junk').returns(@database)
+  test "score_set raises NotImplementedError" do
+    result_set = Linkage::ResultSet.new
+    assert_raises(NotImplementedError) do
+      result_set.score_set
+    end
   end
 
-  test "creating a result set with a configuration" do
-    result_set = Linkage::ResultSet.new(@config)
+  test "match_set raises NotImplementedError" do
+    result_set = Linkage::ResultSet.new
+    assert_raises(NotImplementedError) do
+      result_set.match_set
+    end
   end
 
-  test '#add_group creates two copies when decollation is needed' do
-    result_set = Linkage::ResultSet.new(@config)
-
-    group = stub('group', {
-      :values => {:foo => 'bar '},
-      :decollated_values => {:foo => 'BAR'}
-    })
-
-    groups_import_buffer = stub('groups import buffer')
-    groups_dataset = stub('groups dataset')
-    @database.stubs(:[]).with(:groups).returns(groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(groups_dataset, [:id, :foo]).
-      returns(groups_import_buffer)
-
-    original_groups_import_buffer = stub('original groups import buffer')
-    original_groups_dataset = stub('original groups dataset')
-    @database.stubs(:[]).with(:original_groups).returns(original_groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(original_groups_dataset, [:id, :foo]).
-      returns(original_groups_import_buffer)
-
-    groups_import_buffer.expects(:add).with([1, 'BAR'])
-    original_groups_import_buffer.expects(:add).with([1, 'bar '])
-    result_set.add_group(group)
-  end
-
-  test "#flush! flushes groups dataset" do
-    result_set = Linkage::ResultSet.new(@config)
-
-    group = stub('group', {
-      :values => {:foo => 'bar '},
-      :decollated_values => {:foo => 'BAR'}
-    })
-
-    groups_import_buffer = stub('groups import buffer')
-    groups_dataset = stub('groups dataset')
-    @database.stubs(:[]).with(:groups).returns(groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(groups_dataset, [:id, :foo]).
-      returns(groups_import_buffer)
-
-    original_groups_import_buffer = stub('original groups import buffer')
-    original_groups_dataset = stub('original groups dataset')
-    @database.stubs(:[]).with(:original_groups).returns(original_groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(original_groups_dataset, [:id, :foo]).
-      returns(original_groups_import_buffer)
-
-    groups_import_buffer.stubs(:add)
-    original_groups_import_buffer.stubs(:add)
-    result_set.add_group(group)
-
-    groups_import_buffer.expects(:flush)
-    original_groups_import_buffer.expects(:flush)
-    result_set.flush!
-  end
-
-  test "#add_group doesn't create copies when decollation is not needed" do
-    @config.stubs(:decollation_needed?).returns(false)
-    result_set = Linkage::ResultSet.new(@config)
-
-    group = stub('group', :values => {:foo => 'bar '})
-
-    groups_import_buffer = stub('groups import buffer')
-    groups_dataset = stub('groups dataset', :first_source_table => :groups, :db => @database)
-    @database.stubs(:[]).with(:groups).returns(groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(groups_dataset, [:id, :foo]).
-      returns(groups_import_buffer)
-
-    original_groups_dataset = stub('original groups dataset', :first_source_table => :original_groups, :db => @database)
-    @database.stubs(:[]).with(:original_groups).returns(original_groups_dataset)
-    Linkage::ImportBuffer.expects(:new).with(original_groups_dataset, [:id, :foo]).never
-
-    groups_import_buffer.expects(:add).with([1, 'bar '])
-    result_set.add_group(group)
-  end
-
-  test "#add_score adds to score buffer" do
-    result_set = Linkage::ResultSet.new(@config)
-    scores_dataset = stub('scores dataset')
-    @database.stubs(:[]).with(:scores).returns(scores_dataset)
-    scores_import_buffer = stub('scores import buffer')
-    Linkage::ImportBuffer.expects(:new).
-      with(scores_dataset, [:comparator_id, :record_1_id, :record_2_id, :score]).
-      returns(scores_import_buffer)
-    scores_import_buffer.expects(:add).with([0, 1, 2, 123])
-    scores_import_buffer.expects(:add).with([1, 1, 2, 456])
-    result_set.add_score(0, 1, 2, 123)
-    result_set.add_score(1, 1, 2, 456)
-  end
-
-  test "#flush! flushes score buffer" do
-    result_set = Linkage::ResultSet.new(@config)
-    scores_dataset = stub('scores dataset')
-    @database.stubs(:[]).with(:scores).returns(scores_dataset)
-    scores_import_buffer = stub('scores import buffer')
-    Linkage::ImportBuffer.stubs(:new).
-      with(scores_dataset, [:comparator_id, :record_1_id, :record_2_id, :score]).
-      returns(scores_import_buffer)
-    scores_import_buffer.stubs(:add)
-    result_set.add_score(0, 1, 2, 123)
-
-    scores_import_buffer.expects(:flush)
-    result_set.flush!
-  end
-
-  test "#add_match adds to match buffer" do
-    result_set = Linkage::ResultSet.new(@config)
-    matches_dataset = stub('matches dataset')
-    @database.stubs(:[]).with(:matches).returns(matches_dataset)
-    matches_import_buffer = stub('matches import buffer')
-    Linkage::ImportBuffer.expects(:new).
-      with(matches_dataset, [:record_1_id, :record_2_id, :total_score]).
-      returns(matches_import_buffer)
-    matches_import_buffer.expects(:add).with([1, 2, 123])
-    matches_import_buffer.expects(:add).with([2, 3, 456])
-    result_set.add_match(1, 2, 123)
-    result_set.add_match(2, 3, 456)
-  end
-
-  test "#flush! flushes match buffer" do
-    result_set = Linkage::ResultSet.new(@config)
-    matches_dataset = stub('matches dataset')
-    @database.stubs(:[]).with(:matches).returns(matches_dataset)
-    matches_import_buffer = stub('matches import buffer')
-    Linkage::ImportBuffer.stubs(:new).
-      with(matches_dataset, [:record_1_id, :record_2_id, :total_score]).
-      returns(matches_import_buffer)
-    matches_import_buffer.stubs(:add)
-    result_set.add_match(1, 2, 123)
-
-    matches_import_buffer.expects(:flush)
-    result_set.flush!
-  end
-
-  test "#create_tables! uses custom table names" do
-    @config.stubs({
-      :groups_table_name => :foo_groups,
-      :original_groups_table_name => :foo_original_groups,
-      :scores_table_name => :foo_scores,
-      :matches_table_name => :foo_matches,
-      :groups_table_needed? => true,
-      :decollation_needed? => true,
-      :scores_table_needed? => true,
-      :groups_table_schema => [],
-      :scores_table_schema => [],
-      :matches_table_schema => []
-    })
-    result_set = Linkage::ResultSet.new(@config)
-    @database.expects(:create_table).with(:foo_groups)
-    @database.expects(:create_table).with(:foo_original_groups)
-    @database.expects(:create_table).with(:foo_scores)
-    @database.expects(:create_table).with(:foo_matches)
-    result_set.create_tables!
-  end
-
-  test "#add_group uses custom table names" do
-    @config.stubs({
-      :groups_table_name => :foo_groups,
-      :original_groups_table_name => :foo_original_groups
-    })
-    result_set = Linkage::ResultSet.new(@config)
-
-    group = stub('group', {
-      :values => {:foo => 'bar '},
-      :decollated_values => {:foo => 'BAR'}
-    })
-
-    groups_import_buffer = stub('groups import buffer')
-    groups_dataset = stub('groups dataset')
-    @database.stubs(:[]).with(:foo_groups).returns(groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).with(groups_dataset, [:id, :foo]).
-      returns(groups_import_buffer)
-
-    original_groups_import_buffer = stub('original groups import buffer')
-    original_groups_dataset = stub('original groups dataset')
-    @database.stubs(:[]).with(:foo_original_groups).
-      returns(original_groups_dataset)
-    Linkage::ImportBuffer.stubs(:new).
-      with(original_groups_dataset, [:id, :foo]).
-      returns(original_groups_import_buffer)
-
-    groups_import_buffer.expects(:add).with([1, 'BAR'])
-    original_groups_import_buffer.expects(:add).with([1, 'bar '])
-    result_set.add_group(group)
+  test "getting a registered class" do
+    klass = new_result_set
+    Linkage::ResultSet.register('foo', klass)
+    assert_equal klass, Linkage::ResultSet['foo']
   end
 
-  test "#add_score uses custom table name" do
-    @config.stubs(:scores_table_name).returns(:foo_scores)
-    result_set = Linkage::ResultSet.new(@config)
-    scores_dataset = stub('scores dataset')
-    @database.stubs(:[]).with(:foo_scores).returns(scores_dataset)
-    scores_import_buffer = stub('scores import buffer')
-    Linkage::ImportBuffer.expects(:new).
-      with(scores_dataset,
-        [:comparator_id, :record_1_id, :record_2_id, :score]).
-      returns(scores_import_buffer)
-    scores_import_buffer.expects(:add).with([0, 1, 2, 123])
-    scores_import_buffer.expects(:add).with([1, 1, 2, 456])
-    result_set.add_score(0, 1, 2, 123)
-    result_set.add_score(1, 1, 2, 456)
+  test "registered classes required to define score_set" do
+    klass = new_result_set do
+      remove_method :score_set
+    end
+    assert_raises(ArgumentError) { Linkage::ResultSet.register('foo', klass) }
   end
 
-  test "#add_match uses custom table name" do
-    @config.stubs(:matches_table_name).returns(:foo_matches)
-    result_set = Linkage::ResultSet.new(@config)
-    matches_dataset = stub('matches dataset')
-    @database.stubs(:[]).with(:foo_matches).returns(matches_dataset)
-    matches_import_buffer = stub('matches import buffer')
-    Linkage::ImportBuffer.expects(:new).
-      with(matches_dataset, [:record_1_id, :record_2_id, :total_score]).
-      returns(matches_import_buffer)
-    matches_import_buffer.expects(:add).with([1, 2, 123])
-    matches_import_buffer.expects(:add).with([2, 3, 456])
-    result_set.add_match(1, 2, 123)
-    result_set.add_match(2, 3, 456)
+  test "registered classes required to define match_set" do
+    klass = new_result_set do
+      remove_method :match_set
+    end
+    assert_raises(ArgumentError) { Linkage::ResultSet.register('foo', klass) }
   end
 end

data/test/unit/test_result_sets.rb

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

data/test/unit/test_runner.rb

@@ -2,28 +2,133 @@ require 'helper'
 
 class UnitTests::TestRunner < Test::Unit::TestCase
   def setup
-    @result_set = stub("result set")
-    @config = stub("configuration", :result_set => @result_set)
+    @score_recorder = stub('score recorder')
+    @matcher = stub('matcher')
+    @match_recorder = stub('match recorder')
   end
 
-  test "initialization creates a result set" do
-    runner = Linkage::Runner.new(@config)
-  end
+  sub_test_case('two datasets') do
+    def setup
+      super
+      @dataset_1 = stub('dataset 1')
+      @dataset_2 = stub('dataset 2')
+      @config = stub('config', {
+        :dataset_1 => @dataset_1, :dataset_2 => @dataset_2,
+        :score_recorder => @score_recorder, :match_recorder => @match_recorder,
+        :matcher => @matcher
+      })
+      @runner = Linkage::Runner.new(@config)
+    end
 
-  test "initialization with deprecated uri and options" do
-    @config.expects(:save_results_in).with("foo:/results", {:foo => 'bar'})
-    Linkage::Runner.any_instance.expects(:warn)
-    runner = Linkage::Runner.new(@config, "foo:/results", {:foo => 'bar'})
-  end
+    test "score records with simple comparisons" do
+      comparator_1 = stub('comparator 1', :type => :simple)
+      comparator_2 = stub('comparator 2', :type => :simple)
+      @config.stubs(:comparators).returns([comparator_1, comparator_2])
+      @score_recorder.expects(:start)
+
+      @dataset_1.expects(:each).multiple_yields(
+        [(record_1_1 = {:id => 1, :foo => 123})],
+        [(record_1_2 = {:id => 2, :foo => 456})]
+      )
+      @dataset_2.expects(:each).twice.multiple_yields(
+        [(record_2_1 = {:id => 100, :foo => 123})],
+        [(record_2_2 = {:id => 101, :foo => 456})]
+      )
+
+      comparator_1.expects(:score_and_notify).with(record_1_1, record_2_1)
+      comparator_2.expects(:score_and_notify).with(record_1_1, record_2_1)
+      comparator_1.expects(:score_and_notify).with(record_1_1, record_2_2)
+      comparator_2.expects(:score_and_notify).with(record_1_1, record_2_2)
+      comparator_1.expects(:score_and_notify).with(record_1_2, record_2_1)
+      comparator_2.expects(:score_and_notify).with(record_1_2, record_2_1)
+      comparator_1.expects(:score_and_notify).with(record_1_2, record_2_2)
+      comparator_2.expects(:score_and_notify).with(record_1_2, record_2_2)
+
+      @score_recorder.expects(:stop)
+
+      @runner.score_records
+    end
+
+    test "score records with advanced comparisons" do
+      comparator_1 = stub('comparator 1', :type => :advanced)
+      comparator_2 = stub('comparator 2', :type => :advanced)
+      @config.stubs(:comparators).returns([comparator_1, comparator_2])
+      @score_recorder.expects(:start)
+
+      comparator_1.expects(:score_datasets).with(@dataset_1, @dataset_2)
+      comparator_2.expects(:score_datasets).with(@dataset_1, @dataset_2)
+      @score_recorder.expects(:stop)
+
+      @runner.score_records
+    end
+
+    test "match records" do
+      @config.expects(:matcher).returns(@matcher)
+      @config.expects(:match_recorder).with(@matcher).returns(@match_recorder)
+      @match_recorder.expects(:start)
+      @matcher.expects(:run)
+      @match_recorder.expects(:stop)
 
-  test "execute raises error" do
-    runner = Linkage::Runner.new(@config)
-    assert_raise_kind_of(NotImplementedError) { runner.execute }
+      @runner.match_records
+    end
   end
 
-  test "result_set gets ResultSet from config" do
-    runner = Linkage::Runner.new(@config)
-    @config.expects(:result_set).returns(@result_set)
-    assert_equal @result_set, runner.result_set
+  sub_test_case('one dataset') do
+    def setup
+      super
+      @dataset = stub('dataset')
+      @config = stub('config', {
+        :dataset_1 => @dataset, :dataset_2 => nil,
+        :score_recorder => @score_recorder, :match_recorder => @match_recorder,
+        :matcher => @matcher
+      })
+      @runner = Linkage::Runner.new(@config)
+    end
+
+    test "score records with simple comparisons" do
+      comparator_1 = stub('comparator 1', :type => :simple)
+      comparator_2 = stub('comparator 2', :type => :simple)
+      @config.stubs(:comparators).returns([comparator_1, comparator_2])
+      @score_recorder.expects(:start)
+
+      @dataset.expects(:all).returns([
+        (record_1 = {:id => 1, :foo => 123}),
+        (record_2 = {:id => 2, :foo => 456}),
+        (record_3 = {:id => 3, :foo => 456})
+      ])
+
+      comparator_1.expects(:score_and_notify).with(record_1, record_2)
+      comparator_2.expects(:score_and_notify).with(record_1, record_2)
+      comparator_1.expects(:score_and_notify).with(record_1, record_3)
+      comparator_2.expects(:score_and_notify).with(record_1, record_3)
+      comparator_1.expects(:score_and_notify).with(record_2, record_3)
+      comparator_2.expects(:score_and_notify).with(record_2, record_3)
+      @score_recorder.expects(:stop)
+
+      @runner.score_records
+    end
+
+    test "score records with advanced comparisons" do
+      comparator_1 = stub('comparator 1', :type => :advanced)
+      comparator_2 = stub('comparator 2', :type => :advanced)
+      @config.stubs(:comparators).returns([comparator_1, comparator_2])
+      @score_recorder.expects(:start)
+
+      comparator_1.expects(:score_dataset).with(@dataset)
+      comparator_2.expects(:score_dataset).with(@dataset)
+      @score_recorder.expects(:stop)
+
+      @runner.score_records
+    end
+
+    test "match records" do
+      @config.expects(:matcher).returns(@matcher)
+      @config.expects(:match_recorder).with(@matcher).returns(@match_recorder)
+      @match_recorder.expects(:start)
+      @matcher.expects(:run)
+      @match_recorder.expects(:stop)
+
+      @runner.match_records
+    end
   end
 end

data/test/unit/test_runners.rb

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

data/test/unit/test_score_recorder.rb

@@ -0,0 +1,25 @@
+require 'helper'
+
+class UnitTests::TestScoreRecorder < Test::Unit::TestCase
+  def setup
+    @score_set = stub('score set')
+  end
+
+  test "recording events from comparators" do
+    comparator = stub('comparator')
+    score_recorder = Linkage::ScoreRecorder.new([comparator], @score_set, [:id_1, :id_2])
+
+    comparator.expects(:add_observer).with(score_recorder)
+    @score_set.expects(:open_for_writing)
+    score_recorder.start
+
+    @score_set.expects(:add_score).with(1, 123, 456, 1)
+    record_1 = { :id_1 => 123 }
+    record_2 = { :id_2 => 456 }
+    score_recorder.update(comparator, record_1, record_2, 1)
+
+    comparator.expects(:delete_observer).with(score_recorder)
+    @score_set.expects(:close)
+    score_recorder.stop
+  end
+end

data/test/unit/test_score_set.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+class TestScoreSet < Test::Unit::TestCase
+  test "add_score raises NotImplementedError" do
+    score_set = Linkage::ScoreSet.new
+    assert_raises(NotImplementedError) do
+      score_set.add_score('foo', 'bar', 'baz', 'qux')
+    end
+  end
+
+  test "each_pair raises NotImplementedError" do
+    score_set = Linkage::ScoreSet.new
+    assert_raises(NotImplementedError) do
+      score_set.each_pair { |x| }
+    end
+  end
+
+  test "getting a registered class" do
+    klass = new_score_set
+    Linkage::ScoreSet.register('foo', klass)
+    assert_equal klass, Linkage::ScoreSet['foo']
+  end
+
+  test "registered classes required to define add_score" do
+    klass = new_score_set do
+      remove_method :add_score
+    end
+    assert_raises(ArgumentError) { Linkage::ScoreSet.register('foo', klass) }
+  end
+
+  test "registered classes required to define each_pair" do
+    klass = new_score_set do
+      remove_method :each_pair
+    end
+    assert_raises(ArgumentError) { Linkage::ScoreSet.register('foo', klass) }
+  end
+end

data/test/unit/test_score_sets.rb

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