linkage 0.0.1 → 0.0.2

data/test/unit/test_expectation.rb

@@ -20,6 +20,28 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     assert_equal :dual, exp.kind
   end
 
+  test "kind when one field and one function from different datasets" do
+    dataset_1 = mock('dataset 1')
+    dataset_2 = mock('dataset 2')
+    field = stub_field('field', :dataset => dataset_1)
+    func = stub_function('function', :dataset => dataset_2, :static? => false)
+    field.expects(:==).with(func).returns(false)
+    dataset_1.expects(:==).with(dataset_2).returns(false)
+    exp = Linkage::MustExpectation.new(:==, field, func)
+    assert_equal :dual, exp.kind
+  end
+
+  test "kind when two functions from different datasets" do
+    dataset_1 = mock('dataset 1')
+    dataset_2 = mock('dataset 2')
+    func_1 = stub_function('function 1', :dataset => dataset_1, :static? => false)
+    func_2 = stub_function('function 2', :dataset => dataset_2, :static? => false)
+    func_1.expects(:==).with(func_2).returns(false)
+    dataset_1.expects(:==).with(dataset_2).returns(false)
+    exp = Linkage::MustExpectation.new(:==, func_1, func_2)
+    assert_equal :dual, exp.kind
+  end
+
   test "kind when two identical fields from the same dataset" do
     field_1 = stub_field('field 1')
     field_2 = stub_field('field 2')
@@ -28,6 +50,14 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     assert_equal :self, exp.kind
   end
 
+  test "kind when two identical functions from the same dataset" do
+    func_1 = stub_function('function 1')
+    func_2 = stub_function('function 2')
+    func_1.expects(:==).with(func_2).returns(true)
+    exp = Linkage::MustExpectation.new(:==, func_1, func_2)
+    assert_equal :self, exp.kind
+  end
+
   test "kind when two different fields from the same dataset" do
     dataset_1 = mock('dataset 1')
     dataset_2 = mock('dataset 2')
@@ -39,6 +69,17 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     assert_equal :cross, exp.kind
   end
 
+  test "kind when two different functions from the same dataset" do
+    dataset_1 = mock('dataset 1')
+    dataset_2 = mock('dataset 2')
+    func_1 = stub_function('function 1', :dataset => dataset_1)
+    func_2 = stub_function('function 2', :dataset => dataset_2)
+    func_1.expects(:==).with(func_2).returns(false)
+    dataset_1.expects(:==).with(dataset_2).returns(true)
+    exp = Linkage::MustExpectation.new(:==, func_1, func_2)
+    assert_equal :cross, exp.kind
+  end
+
   test "manually set kind with two different fields from the same dataset" do
     dataset = mock('dataset 1')
     field_1 = stub_field('field 1', :dataset => dataset)
@@ -71,6 +112,30 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     exp.apply_to(dataset_2)
   end
 
+  test "apply a two-function dual expectation to two datasets" do
+    dataset_1 = stub('dataset 1')
+    dataset_2 = stub('dataset 2')
+    func_1 = stub_function('function 1', :name => :foo, :dataset => dataset_1) do
+      stubs(:belongs_to?).with(dataset_1).returns(true)
+      stubs(:belongs_to?).with(dataset_2).returns(false)
+    end
+    func_2 = stub_function('function 2', :name => :bar, :dataset => dataset_2) do
+      stubs(:belongs_to?).with(dataset_2).returns(true)
+      stubs(:belongs_to?).with(dataset_1).returns(false)
+    end
+    merged_field = stub_field('merged field', :name => :foo_bar)
+    func_1.stubs(:merge).with(func_2).returns(merged_field)
+    exp = Linkage::MustExpectation.new(:==, func_1, func_2)
+
+    dataset_1.expects(:add_order).with(func_1)
+    dataset_1.expects(:add_select).with(func_1, :foo_bar)
+    exp.apply_to(dataset_1)
+
+    dataset_2.expects(:add_order).with(func_2)
+    dataset_2.expects(:add_select).with(func_2, :foo_bar)
+    exp.apply_to(dataset_2)
+  end
+
   test "apply a two-field dual expectation to two datasets with an alias" do
     dataset_1 = stub('dataset 1')
     dataset_2 = stub('dataset 2')
@@ -142,6 +207,20 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     exp.apply_to(dataset)
   end
 
+  test "apply a two-function self expectation" do
+    dataset = stub('dataset')
+    func = stub_function('function', :name => :foo, :dataset => dataset) do
+      expects(:belongs_to?).with(dataset).twice.returns(true)
+    end
+    exp = Linkage::MustExpectation.new(:==, func, func)
+
+    # Twice is okay, since add_order/add_select will take care of
+    # duplicates.
+    dataset.expects(:add_order).twice.with(func)
+    dataset.expects(:add_select).twice.with(func, :foo)
+    exp.apply_to(dataset)
+  end
+
   test "apply a two-field self expectation like a cross" do
     dataset_1 = stub('dataset 1')
     dataset_2 = stub('dataset 2')
@@ -174,12 +253,19 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     assert_equal :foo_bar, exp.name
   end
 
-  test "expectation with static value" do
+  test "expectation with static value is of type 'filter'" do
     field = stub_field('field')
     exp = Linkage::MustExpectation.new(:==, field, 123)
     assert_equal :filter, exp.kind
   end
 
+  test "expectation with static function is of type 'filter'" do
+    field = stub_field('field')
+    func = stub_function('func', :static? => true)
+    exp = Linkage::MustExpectation.new(:==, field, func)
+    assert_equal :filter, exp.kind
+  end
+
   test "apply filter expectation" do
     dataset_1 = stub('dataset 1')
     dataset_2 = stub('dataset 2')
@@ -291,4 +377,14 @@ class UnitTests::TestExpectation < Test::Unit::TestCase
     field.expects(:belongs_to?).with(dataset_2).returns(false)
     exp.apply_to(dataset_2)
   end
+
+  test "allows a dynamic function filter" do
+    func = stub_function("foo", :static? => false)
+    exp = Linkage::MustNotExpectation.new(:==, func, 123)
+  end
+
+  test "does not allow a static function filter" do
+    func = stub_function("foo", :static? => true)
+    assert_raises(ArgumentError) { Linkage::MustNotExpectation.new(:==, func, 123) }
+  end
 end

data/test/unit/test_field.rb

@@ -7,6 +7,10 @@ class UnitTests::TestField < Test::Unit::TestCase
     f
   end
 
+  test "subclass of data" do
+    assert_equal Linkage::Data, Linkage::Field.superclass
+  end
+
   test "initialize with schema info" do
     schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
     field = Linkage::Field.new(:id, schema)
@@ -21,420 +25,15 @@ class UnitTests::TestField < Test::Unit::TestCase
     assert_equal info, field.ruby_type
   end
 
-  test "merge two identical fields" do
-    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    expected_type = {:type => Integer}
-
-    result_field = field_1.merge(field_2)
-    assert_equal(:id, result_field.name)
-    assert_equal(expected_type, result_field.ruby_type)
-
-    result_field = field_2.merge(field_1)
-    assert_equal(:id, result_field.name)
-    assert_equal(expected_type, result_field.ruby_type)
-  end
-
-  test "merge fields with different names" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:bar, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-
-    result_field = field_1.merge(field_2)
-    assert_equal(:foo_bar, result_field.name)
-    result_field = field_2.merge(field_1)
-    assert_equal(:bar_foo, result_field.name)
-  end
-
-  test "merge two boolean fields" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => TrueClass}
-
-    result_field = field_1.merge(field_2)
-    assert_equal(:foo, result_field.name)
-    assert_equal(expected_type, result_field.ruby_type)
-
-    result_field = field_2.merge(field_1)
-    assert_equal(:foo, result_field.name)
-    assert_equal(expected_type, result_field.ruby_type)
-  end
-
-  test "merge a boolean field and an integer field" do
-    field_1 = Linkage::Field.new(: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=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => Integer}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a bignum field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => Bignum}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a float field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => Float}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a decimal field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a decimal field with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a boolean field and a fixed string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"boolean", :type=>:boolean, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two integer fields" do
-    field_1 = Linkage::Field.new(: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})
-    expected_type = {:type => Integer}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a bignum field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :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})
-    expected_type = {:type => Bignum}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a float field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :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})
-    expected_type = {:type => Float}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a decimal field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :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})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a decimal field with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :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})
-    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :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})
-    expected_type = {:type => String, :opts => {:size => 10}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :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})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an integer field and a fixed string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :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})
-    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two bignum fields" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => Bignum}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an bignum field and a decimal field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an bignum field and a decimal field with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an bignum field and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an bignum field and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge an bignum field and a fixed string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two float fields" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => Float}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a bignum field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"bigint", :type=>:bigint, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a decimal field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a decimal field with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a float field and a fixed string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"float", :type=>:float, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two decimal fields" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two decimal fields, one with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two decimal fields, both with size" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10,2)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,1)", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [12, 2]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two decimal fields, both with size, one without scale" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(10)", :type=>:decimal, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,1)", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => BigDecimal, :opts => {:size => [12, 1]}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a decimal field and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a decimal field with size and a string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,2)", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 13}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a decimal field and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a decimal field with size and a text field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"text", :type=>:text, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal(12,2)", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:text => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge a decimal field and a fixed string field" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"char(10)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"decimal", :type=>:decimal, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two string fields" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 20}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two string fields with different sizes" do
-    field_1 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(15)", :type=>:string, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(20)", :type=>:string, :ruby_default=>nil})
-    expected_type = {:type => String, :opts => {:size => 20}}
-    assert_equal(expected_type, field_1.merge(field_2).ruby_type)
-    assert_equal(expected_type, field_2.merge(field_1).ruby_type)
-  end
-
-  test "merge two fields and specify name" do
-    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_2 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-
-    result_field = field_1.merge(field_2, 'foo')
-    assert_equal :foo, result_field.name
-
-    result_field = field_2.merge(field_1, 'foo')
-    assert_equal :foo, result_field.name
-  end
-
-  test "== returns true when fields have the same name and are from the same dataset" do
-    dataset_1 = stub('dataset')
-    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_1.dataset = dataset_1
-    dataset_2 = stub('dataset clone')
-    field_2 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_2.dataset = dataset_2
-
-    dataset_1.expects(:==).with(dataset_2).returns(true)
-    assert_equal field_1, field_2
-  end
-
-  test "== returns false when fields have the same name but are from different datasets" do
-    dataset_1 = stub('dataset 1')
-    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_1.dataset = dataset_1
-    dataset_2 = stub('dataset 2')
-    field_2 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field_2.dataset = dataset_2
-
-    dataset_1.expects(:==).with(dataset_2).returns(false)
-    assert_not_equal field_1, field_2
-  end
-
-  test "belongs_to? dataset" do
-    dataset = stub('dataset 1', :id => 1)
-    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field.dataset = dataset
-    assert field.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)
-    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field.dataset = dataset_1
-    assert field.belongs_to?(dataset_2)
+  test "static? is always false" do
+    schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
+    field = Linkage::Field.new(:id, schema)
+    assert !field.static?
   end
 
-  test "belongs_to? dataset with different id" do
-    dataset_1 = stub('dataset 1', :id => 1)
-    dataset_2 = stub('dataset 2', :id => 2)
+  test "ruby_type for integer" do
     field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
-    field.dataset = dataset_1
-    assert !field.belongs_to?(dataset_2)
+    assert_equal({:type => Integer}, field.ruby_type)
   end
 
   test "primary_key? returns true if primary key" do
@@ -444,4 +43,9 @@ class UnitTests::TestField < Test::Unit::TestCase
     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
+    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    assert_equal :id, field.to_expr
+  end
 end