linkage 0.0.6 → 0.0.8

data/test/unit/test_meta_object.rb

@@ -0,0 +1,208 @@
+require 'helper'
+
+class UnitTests::TestMetaObject < Test::Unit::TestCase
+  test "initialize with static string" do
+    meta_object = Linkage::MetaObject.new("foo")
+    assert meta_object.static?
+    assert_equal "foo", meta_object.object
+    assert_nil meta_object.side
+  end
+
+  test "initialize with static function" do
+    function = stub_function("foo", :static? => true)
+    meta_object = Linkage::MetaObject.new(function)
+    assert meta_object.static?
+    assert_equal function, meta_object.object
+    assert_nil meta_object.side
+  end
+
+  test "initialize with field" do
+    field = stub_field("foo")
+    meta_object = Linkage::MetaObject.new(field, :lhs)
+    assert !meta_object.static?
+    assert_equal field, meta_object.object
+    assert_equal :lhs, meta_object.side
+  end
+
+  test "getting side for dynamic object without setting it raises error" do
+    meta_object = Linkage::MetaObject.new(stub_field('foo'))
+    assert_raises(RuntimeError) { meta_object.side }
+  end
+
+  test "getting dataset calls #dataset on object" do
+    field = stub_field('foo')
+    meta_object = Linkage::MetaObject.new(field)
+
+    dataset = stub('dataset')
+    field.expects(:dataset).returns(dataset)
+    assert_equal dataset, meta_object.dataset
+  end
+
+  test "setting dataset sets object's dataset" do
+    func = stub_function('foo')
+    meta_object = Linkage::MetaObject.new(func)
+
+    dataset = stub('dataset')
+    func.expects(:dataset=).with(dataset)
+    meta_object.dataset = dataset
+  end
+
+  test "setting dataset on non-data object raises exception" do
+    meta_object = Linkage::MetaObject.new(123)
+    dataset = stub('dataset')
+    assert_raises(RuntimeError) { meta_object.dataset = dataset }
+  end
+
+  test "objects_equal? compares only objects, not sides" do
+    field = stub_field("foo")
+    object_1 = Linkage::MetaObject.new(field, :lhs)
+    object_2 = Linkage::MetaObject.new(field, :rhs)
+    object_3 = Linkage::MetaObject.new(123)
+    assert object_1.objects_equal?(object_2)
+    assert !object_1.objects_equal?("foo")
+    assert !object_2.objects_equal?(object_3)
+  end
+
+  test "dataset reader for field" do
+    dataset = stub('dataset')
+    field = stub_field("foo", :dataset => dataset)
+    object = Linkage::MetaObject.new(field, :lhs)
+
+    assert_equal dataset, object.dataset
+  end
+
+  test "dataset reader for function" do
+    dataset = stub('dataset')
+    function = stub_function("foo", :dataset => dataset)
+    object = Linkage::MetaObject.new(function, :lhs)
+
+    assert_equal dataset, object.dataset
+  end
+
+  test "datasets_equal?" do
+    dataset_1 = stub('dataset 1')
+    field_1 = stub_field('field 1', :dataset => dataset_1)
+    object_1 = Linkage::MetaObject.new(field_1, :lhs)
+
+    dataset_2 = stub('dataset 2')
+    field_2 = stub_field('field 2', :dataset => dataset_2)
+    object_2 = Linkage::MetaObject.new(field_2, :rhs)
+
+    field_3 = stub_field('field 3', :dataset => dataset_2)
+    object_3 = Linkage::MetaObject.new(field_3, :rhs)
+
+    object_4 = Linkage::MetaObject.new(123)
+
+    assert object_1.datasets_equal?(object_1)
+    assert object_2.datasets_equal?(object_3)
+    assert !object_1.datasets_equal?(object_2)
+    assert !object_1.datasets_equal?("foo")
+    assert !object_1.datasets_equal?(object_4)
+  end
+
+  test "to_expr for non-data object returns object" do
+    object = Linkage::MetaObject.new(123)
+    assert_equal 123, object.to_expr
+  end
+
+  test "to_expr for data object returns object.to_expr" do
+    field = stub_field('field')
+    object = Linkage::MetaObject.new(field, :lhs)
+
+    field.expects(:to_expr).returns(:foo)
+    assert_equal :foo, object.to_expr
+  end
+
+  test "to_identifier for non-data object returns object" do
+    object = Linkage::MetaObject.new(123)
+    assert_equal 123, object.to_identifier
+  end
+
+  test "to_identifer for data object returns identifier object" do
+    field = stub_field('field')
+    object = Linkage::MetaObject.new(field, :lhs)
+
+    field.expects(:to_expr).returns(:foo)
+    assert_equal(Sequel::SQL::Identifier.new(:foo), object.to_identifier)
+  end
+
+  test "merge with data object" do
+    field_1 = stub_field('field 1')
+    object_1 = Linkage::MetaObject.new(field_1, :lhs)
+    field_2 = stub_field('field 2')
+    object_2 = Linkage::MetaObject.new(field_2, :rhs)
+
+    merged_field = stub('merged field')
+    field_1.expects(:merge).with(field_2).returns(merged_field)
+    assert_equal merged_field, object_1.merge(object_2)
+  end
+
+  test "merge with non-data object raises exception" do
+    field_1 = stub_field('field 1')
+    object_1 = Linkage::MetaObject.new(field_1, :lhs)
+    object_2 = Linkage::MetaObject.new(123)
+    assert_raises(ArgumentError) { object_1.merge(object_2) }
+    assert_raises(ArgumentError) { object_2.merge(object_1) }
+  end
+
+  test "ruby_type calls Field#ruby_type" do
+    field = stub_field('field')
+    object = Linkage::MetaObject.new(field, :lhs)
+    field.expects(:ruby_type).returns(:type => String)
+    assert_equal({:type => String}, object.ruby_type)
+  end
+
+  test "ruby_type calls Function#ruby_type" do
+    function = stub_function("foo")
+    object = Linkage::MetaObject.new(function, :lhs)
+    function.expects(:ruby_type).returns(:type => String)
+    assert_equal({:type => String}, object.ruby_type)
+  end
+
+  test "ruby_type returns object class for non-data object" do
+    object = Linkage::MetaObject.new(123)
+    assert_equal({:type => Fixnum}, object.ruby_type)
+  end
+
+  test "database_type" do
+    dataset = mock('dataset')
+    field = stub_field('field', :dataset => dataset)
+    object = Linkage::MetaObject.new(field, :lhs)
+    dataset.expects(:database_type).returns(:mysql)
+    assert_equal :mysql, object.database_type
+  end
+
+  test "#collation returns Data#collation" do
+    dataset = mock('dataset')
+    field = stub_field('field', :dataset => dataset, :collation => 'foo')
+    object = Linkage::MetaObject.new(field, :lhs)
+    assert_equal 'foo', object.collation
+  end
+
+  test "#collation returns nil when underlying object is not a Data object" do
+    object = Linkage::MetaObject.new(123, :lhs)
+    assert_nil object.collation
+  end
+
+  test "#name for data object" do
+    field = stub_field('foo', :name => :foo)
+    object = Linkage::MetaObject.new(field, :lhs)
+    assert_equal :foo, object.name
+  end
+
+  test "#name for non-data object returns nil" do
+    object = Linkage::MetaObject.new(123)
+    assert_nil object.name
+  end
+
+  test "#raw? returns true for non-data object" do
+    object = Linkage::MetaObject.new(123)
+    assert object.raw?
+  end
+
+  test "#raw? returns false for data object" do
+    field = stub_field('foo', :name => :foo)
+    object = Linkage::MetaObject.new(field, :lhs)
+    assert !object.raw?
+  end
+end

data/test/unit/test_result_set.rb

@@ -4,15 +4,233 @@ class TestResultSet < Test::Unit::TestCase
   def setup
     @config = stub('configuration', {
       :results_uri => 'foo://bar',
-      :results_uri_options => {:blah => 'junk'}
+      :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)
   end
 
   test "creating a result set with a configuration" do
     result_set = Linkage::ResultSet.new(@config)
   end
 
-  test "records?" do
-    pend
+  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)
+  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)
+  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)
   end
 end