linkage 0.0.2 → 0.0.3

data/test/integration/test_cross_linkage.rb

@@ -24,10 +24,12 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:foo].must == rhs[:bar]
+        save_results_in(tmpuri, :single_threaded => true)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri, :single_threaded => true)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -52,12 +54,14 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:foo].must == rhs[:foo]
         lhs[:bar].must == 0
         rhs[:bar].must == 10
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|

data/test/integration/test_dataset.rb

@@ -0,0 +1,30 @@
+require 'helper'
+
+class IntegrationTests::TestDataset < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir('linkage')
+    @tmpuri = "sqlite://" + File.join(@tmpdir, "foo")
+  end
+
+  def database(&block)
+    Sequel.connect(@tmpuri, &block)
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@tmpdir)
+  end
+
+  test "methods that clone the dataset" do
+    database do |db|
+      db.create_table(:foo) do
+        primary_key :id
+        String :bar
+      end
+    end
+    ds_1 = Linkage::Dataset.new(@tmpuri, "foo")
+    ds_2 = ds_1.filter(:foo => 'bar')
+    assert_instance_of Linkage::Dataset, ds_2
+    assert_equal ds_2.field_set, ds_1.field_set
+    assert_match /`foo` = 'bar'/, ds_2.sql
+  end
+end

data/test/integration/test_dual_linkage.rb

@@ -29,10 +29,12 @@ module IntegrationTests
 
       ds_1 = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
       ds_2 = Linkage::Dataset.new(@tmpuri, "bar", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds_1.link_with(ds_2) do
         lhs[:ssn].must == rhs[:ssn]
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -68,10 +70,12 @@ module IntegrationTests
 
       ds_1 = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
       ds_2 = Linkage::Dataset.new(@tmpuri, "bar", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds_1.link_with(ds_2) do
         lhs[:ssn].must == rhs[:ssn]
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -101,13 +105,14 @@ module IntegrationTests
 
       ds_1 = Linkage::Dataset.new(uri, "foo", :single_threaded => true)
       ds_2 = Linkage::Dataset.new(uri, "bar", :single_threaded => true)
+      logger = Logger.new(STDERR)
       conf = ds_1.link_with(ds_2) do
         lhs[:one].must == rhs[:one]
         lhs[:two].must == rhs[:two]
+        save_results_in(uri, :logger => logger)
       end
 
-      logger = Logger.new(STDERR)
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri, :logger => logger)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       Sequel.connect(@tmpuri) do |db|

data/test/integration/test_self_linkage.rb

@@ -24,11 +24,14 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
-      runner.execute
+      runner = Linkage::SingleThreadedRunner.new(conf)
+      result_set = runner.execute
+      assert_kind_of Linkage::ResultSet, result_set
 
       database do |db|
         assert_equal 10, db[:groups].count
@@ -54,11 +57,13 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
         lhs[:dob].must == rhs[:dob]
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -87,11 +92,13 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
         lhs[:mod_5].must == 3
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -118,12 +125,14 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
         lhs[:mod_5].must > 2
         lhs[:mod_5].must <= 3
+        save_results_in(tmpuri)
       end
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -150,12 +159,14 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
         lhs[:mod_5].must == lhs[:mod_20]
+        save_results_in(tmpuri)
       end
       assert_equal :self, conf.linkage_type
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -182,13 +193,15 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         lhs[:ssn].must == rhs[:ssn]
         lhs[:mod_5].must == lhs[:mod_20]
         rhs[:mod_5].must == rhs[:mod_20]
+        save_results_in(tmpuri)
       end
       assert_equal :self, conf.linkage_type
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|
@@ -215,11 +228,13 @@ module IntegrationTests
       end
 
       ds = Linkage::Dataset.new(@tmpuri, "foo", :single_threaded => true)
+      tmpuri = @tmpuri
       conf = ds.link_with(ds) do
         trim(lhs[:bar]).must == trim(rhs[:bar])
+        save_results_in(tmpuri)
       end
       assert_equal :self, conf.linkage_type
-      runner = Linkage::SingleThreadedRunner.new(conf, @tmpuri)
+      runner = Linkage::SingleThreadedRunner.new(conf)
       runner.execute
 
       database do |db|

data/test/unit/test_configuration.rb

@@ -15,23 +15,22 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
   end
 
   test "linkage_type is cross when there's a 'cross-join'" do
-    dataset = mock('dataset', :set_new_id => nil)
+    field_1 = stub('field_1', :to_expr => :foo)
+    field_2 = stub('field_2', :to_expr => :bar)
+    dataset = stub('dataset', :field_set => {:foo => field_1, :bar => :field_2})
     c = Linkage::Configuration.new(dataset, dataset)
-    exp = stub('expectation', :kind => :cross)
-    c.add_expectation(exp)
+    c.configure do
+      lhs[:foo].must == rhs[:bar]
+    end
     assert_equal :cross, c.linkage_type
   end
 
   test "linkage_type is cross when there's different filters on both sides" do
-    field = stub_field('field')
-    dataset = stub('dataset', :set_new_id => nil)
-    dataset.stubs(:fields).returns({:foo => field})
+    field = stub('field', :to_expr => :foo)
+    dataset = stub('dataset')
+    dataset.stubs(:field_set).returns({:foo => field})
     c = Linkage::Configuration.new(dataset, dataset)
-    exp_1 = stub('expectation', :kind => :filter)
-    Linkage::MustExpectation.expects(:new).with(:==, field, 123, nil).returns(exp_1)
-    exp_2 = stub('expectation', :kind => :filter)
-    Linkage::MustExpectation.expects(:new).with(:==, field, 456, nil).returns(exp_2)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must == 123
       rhs[:foo].must == 456
     end
@@ -39,13 +38,12 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
   end
 
   test "linkage_type is self when there's identical static filters on each side" do
-    field = stub_field('field')
-    dataset = stub('dataset', :set_new_id => nil)
-    dataset.stubs(:fields).returns({:foo => field})
+    field = stub('field', :to_expr => :foo)
+    dataset = stub('dataset')
+    dataset.stubs(:field_set).returns({:foo => field})
     c = Linkage::Configuration.new(dataset, dataset)
     exp_1 = stub('expectation', :kind => :filter)
-    Linkage::MustExpectation.expects(:new).twice.with(:==, field, 123, nil).returns(exp_1)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must == 123
       rhs[:foo].must == 123
     end
@@ -53,16 +51,12 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
   end
 
   test "linkage_type is self when there's a two-field filter on one side" do
-    field_1 = stub_field('field 1')
-    field_2 = stub_field('field 2')
-    dataset = stub('dataset', :set_new_id => nil)
-    dataset.stubs(:fields).returns({:foo => field_1, :bar => field_2})
+    field_1 = stub('field 1', :to_expr => :foo)
+    field_2 = stub('field 2', :to_expr => :bar)
+    dataset = stub('dataset')
+    dataset.stubs(:field_set).returns({:foo => field_1, :bar => field_2})
     c = Linkage::Configuration.new(dataset, dataset)
-    exp_1 = stub('expectation', :kind => :filter)
-    Linkage::MustExpectation.expects(:new).with(:==, field_1, field_2, :filter).returns(exp_1)
-    exp_2 = stub('expectation', :kind => :self)
-    Linkage::MustExpectation.expects(:new).with(:==, field_1, field_1, nil).returns(exp_2)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must == lhs[:bar]
       lhs[:foo].must == rhs[:foo]
     end
@@ -71,111 +65,135 @@ class UnitTests::TestConfiguration < Test::Unit::TestCase
 
   test "static expectation" do
     dataset_1 = stub('dataset')
-    field = stub_field('field')
-    dataset_1.stubs(:fields).returns({:foo => field})
+    field = stub('field', :to_expr => :foo)
+    dataset_1.stubs(:field_set).returns({:foo => field})
     dataset_2 = stub('dataset')
     c = Linkage::Configuration.new(dataset_1, dataset_2)
-    Linkage::MustExpectation.expects(:new).with(:==, field, 123, nil)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must == 123
     end
+    dataset_1.expects(:filter).with({:foo => 123}).returns(dataset_1)
+    c.expectations[0].apply_to(dataset_1, :lhs)
   end
 
-  ## Maybe in the future
-  #test "static expectation, flopped" do
-    #dataset_1 = stub('dataset')
-    #field = stub_field('field')
-    #dataset_1.stubs(:fields).returns({:foo => field})
-    #dataset_2 = stub('dataset')
-    #c = Linkage::Configuration.new(dataset_1, dataset_2)
-    #Linkage::MustExpectation.expects(:new).with(:==, 123, field)
-    #c.send(:instance_eval) do
-      #123.must == lhs[:foo]
-    #end
-  #end
-
   test "complain if an invalid field is accessed" do
     dataset_1 = stub('dataset')
-    field_1 = stub_field('field 1')
-    dataset_1.stubs(:fields).returns({:foo => field_1})
+    field_1 = stub('field 1')
+    dataset_1.stubs(:field_set).returns({:foo => field_1})
 
     dataset_2 = stub('dataset')
-    field_2 = stub_field('field 2')
-    dataset_2.stubs(:fields).returns({:bar => field_2})
+    field_2 = stub('field 2')
+    dataset_2.stubs(:field_set).returns({:bar => field_2})
 
     c = Linkage::Configuration.new(dataset_1, dataset_2)
     assert_raises(ArgumentError) do
-      c.send(:instance_eval) do
+      c.configure do
         lhs[:foo].must == rhs[:non_existant_field]
       end
     end
   end
 
   operators = [:>, :<, :>=, :<=]
-  operators << :'!='  if current_ruby_version >= ruby19
   operators.each do |operator|
     test "DSL #{operator} filter operator" do
       dataset_1 = stub('dataset 1')
-      field_1 = stub_field('field 1')
-      dataset_1.stubs(:fields).returns({:foo => field_1})
+      field_1 = stub('field 1', :to_expr => :foo)
+      dataset_1.stubs(:field_set).returns({:foo => field_1})
 
       dataset_2 = stub('dataset 2')
-      field_2 = stub_field('field 2')
-      dataset_2.stubs(:fields).returns({:bar => field_2})
 
       c = Linkage::Configuration.new(dataset_1, dataset_2)
-      Linkage::MustExpectation.expects(:new).with(operator, field_1, field_2, nil)
       block = eval("Proc.new { lhs[:foo].must #{operator} rhs[:bar] }")
-      c.send(:instance_eval, &block)
+      c.configure do
+        lhs[:foo].must.send(operator, 123)
+      end
+      expr = Sequel::SQL::BooleanExpression.new(operator, Sequel::SQL::Identifier.new(:foo), 123)
+      dataset_1.expects(:filter).with(expr).returns(dataset_1)
+      c.expectations[0].apply_to(dataset_1, :lhs)
     end
   end
 
   test "must_not expectation" do
     dataset_1 = stub('dataset 1')
-    field_1 = stub_field('field 1')
-    dataset_1.stubs(:fields).returns({:foo => field_1})
+    field_1 = stub('field 1', :to_expr => :foo)
+    dataset_1.stubs(:field_set).returns({:foo => field_1})
     dataset_2 = stub('dataset 2')
 
     c = Linkage::Configuration.new(dataset_1, dataset_2)
-    Linkage::MustNotExpectation.expects(:new).with(:==, field_1, 123, nil)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must_not == 123
     end
+    dataset_1.expects(:filter).with(~{:foo => 123}).returns(dataset_1)
+    c.expectations[0].apply_to(dataset_1, :lhs)
   end
 
   test "dynamic database function" do
     dataset_1 = stub('dataset')
-    field_1 = stub_field('field 1')
-    dataset_1.stubs(:fields).returns({:foo => field_1})
+    field_1 = stub('field 1')
+    dataset_1.stubs(:field_set).returns({:foo => field_1})
     dataset_2 = stub('dataset')
-    field_2 = stub_field('field 2')
-    dataset_2.stubs(:fields).returns({:foo => field_2})
+    field_2 = stub('field 2', :to_expr => :foo)
+    dataset_2.stubs(:field_set).returns({:foo => field_2})
 
-    func = stub_function('function', :static? => false)
+    func_expr = stub('function expression') do
+      expects(:as).with(:trim_foo_foo).returns(self)
+    end
+    func = stub('function', :static? => false, :to_expr => func_expr)
     Linkage::Functions::Trim.expects(:new).with(field_1).returns(func)
+    merged_field = stub('merged field', :name => :trim_foo_foo)
+    func.expects(:merge).with(field_2).returns(merged_field)
 
     c = Linkage::Configuration.new(dataset_1, dataset_2)
-    Linkage::MustExpectation.expects(:new).with(:==, func, field_2, nil)
-    c.send(:instance_eval) do
+    c.configure do
       trim(lhs[:foo]).must == rhs[:foo]
     end
+    dataset_1.expects(:select_more).with(func_expr).returns(dataset_1)
+    dataset_1.expects(:order_more).with(func_expr).returns(dataset_1)
+    c.expectations[0].apply_to(dataset_1, :lhs)
+
+    dataset_2.expects(:select_more).with(:foo.as(:trim_foo_foo)).returns(dataset_2)
+    dataset_2.expects(:order_more).with(:foo).returns(dataset_2)
+    c.expectations[0].apply_to(dataset_2, :rhs)
   end
 
   test "static database function" do
     dataset_1 = stub('dataset')
-    field_1 = stub_field('field 1')
-    dataset_1.stubs(:fields).returns({:foo => field_1})
+    field_1 = stub('field 1', :to_expr => :foo)
+    dataset_1.stubs(:field_set).returns({:foo => field_1})
     dataset_2 = stub('dataset')
-    field_2 = stub_field('field 2')
-    dataset_2.stubs(:fields).returns({:foo => field_2})
+    field_2 = stub('field 2')
+    dataset_2.stubs(:field_set).returns({:foo => field_2})
 
-    func = stub_function('function', :static? => true)
+    func_expr = stub('function expression')
+    func = stub('function', :static? => true, :to_expr => func_expr)
     Linkage::Functions::Trim.expects(:new).with("foo").returns(func)
 
     c = Linkage::Configuration.new(dataset_1, dataset_2)
-    Linkage::MustExpectation.expects(:new).with(:==, field_1, func, :filter)
-    c.send(:instance_eval) do
+    c.configure do
       lhs[:foo].must == trim("foo")
     end
+    dataset_1.expects(:filter).with({:foo => func_expr}).returns(dataset_1)
+    c.expectations[0].apply_to(dataset_1, :lhs)
+  end
+
+  test "save_results_in" do
+    dataset_1 = stub('dataset')
+    dataset_2 = stub('dataset')
+    c = Linkage::Configuration.new(dataset_1, dataset_2)
+    c.configure do
+      save_results_in("mysql://localhost/results", {:foo => 'bar'})
+    end
+    assert_equal "mysql://localhost/results", c.results_uri
+    assert_equal({:foo => 'bar'}, c.results_uri_options)
+  end
+
+  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
   end
 end

data/test/unit/test_data.rb

@@ -19,11 +19,6 @@ class UnitTests::TestData < Test::Unit::TestCase
     assert_raises(NotImplementedError) { d.ruby_type }
   end
 
-  test "dataset raises NotImplementedError" do
-    d = Linkage::Data.new(:foo)
-    assert_raises(NotImplementedError) { d.dataset }
-  end
-
   test "to_expr raises NotImplementedError" do
     d = Linkage::Data.new(:foo)
     assert_raises(NotImplementedError) { d.to_expr }
@@ -397,60 +392,4 @@ class UnitTests::TestData < Test::Unit::TestCase
     result_data = data_2.merge(data_1, 'foo')
     assert_equal :foo, result_data.name
   end
-
-  test "== returns true when data have the same name and are from the same dataset" do
-    dataset_1 = stub('dataset')
-    data_1 = new_data(:foo, {:type => Integer}, dataset_1)
-    dataset_2 = stub('dataset clone')
-    data_2 = new_data(:foo, {:type => Integer}, dataset_2)
-
-    dataset_1.expects(:==).with(dataset_2).returns(true)
-    assert_equal data_1, data_2
-  end
-
-  test "== returns false when data have different classes" do
-    dataset_1 = stub('dataset')
-    data_1 = new_data(:foo, {:type => Integer}, dataset_1, DataSubclass)
-    dataset_2 = stub('dataset clone')
-    data_2 = new_data(:foo, {:type => Integer}, dataset_2, DataSubclass.clone)
-    assert_not_equal data_1, data_2
-  end
-
-  test "== returns false when data have the same name but are from different datasets" do
-    dataset_1 = stub('dataset')
-    data_1 = new_data(:foo, {:type => Integer}, dataset_1)
-    dataset_2 = stub('dataset clone')
-    data_2 = new_data(:foo, {:type => Integer}, dataset_2)
-
-    dataset_1.expects(:==).with(dataset_2).returns(false)
-    assert_not_equal data_1, data_2
-  end
-
-  test "== returns true for identical static functions" do
-    klass = new_function('foo', {:type => String})
-    func_1 = klass.new(123)
-    func_2 = klass.new(123)
-
-    assert_equal func_1, func_2
-  end
-
-  test "belongs_to? dataset" do
-    dataset = stub('dataset 1', :id => 1)
-    data = new_data(:foo, {:type => Integer}, dataset)
-    assert data.belongs_to?(dataset)
-  end
-
-  test "belongs_to? dataset with same id" do
-    dataset_1 = stub('dataset 1', :id => 1)
-    dataset_2 = stub('dataset 2', :id => 1)
-    data = new_data(:foo, {:type => Integer}, dataset_1)
-    assert data.belongs_to?(dataset_2)
-  end
-
-  test "belongs_to? dataset with different id" do
-    dataset_1 = stub('dataset 1', :id => 1)
-    dataset_2 = stub('dataset 2', :id => 2)
-    data = new_data(:foo, {:type => Integer}, dataset_1)
-    assert !data.belongs_to?(dataset_2)
-  end
 end