linkage 0.0.1 → 0.0.2

data/test/unit/test_data.rb

@@ -0,0 +1,456 @@
+require 'helper'
+
+class UnitTests::TestData < Test::Unit::TestCase
+  class DataSubclass < Linkage::Data
+    attr_reader :ruby_type, :dataset
+    def initialize(name, ruby_type, dataset = nil)
+      super(name)
+      @ruby_type = ruby_type
+      @dataset = dataset
+    end
+  end
+
+  def new_data(name, ruby_type, dataset = nil, klass = DataSubclass)
+    klass.new(name, ruby_type, dataset)
+  end
+
+  test "ruby_type raises NotImplementedError" do
+    d = Linkage::Data.new(:foo)
+    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 }
+  end
+
+  test "merge two identical fields" do
+    data_1 = new_data(:id, {:type =>Integer})
+    data_2 = new_data(:id, {:type =>Integer})
+    expected_type = {:type => Integer}
+
+    result_data = data_1.merge(data_2)
+    assert_equal(:id, result_data.name)
+    assert_equal(expected_type, result_data.ruby_type)
+
+    result_data = data_2.merge(data_1)
+    assert_equal(:id, result_data.name)
+    assert_equal(expected_type, result_data.ruby_type)
+  end
+
+  test "merge fields with different names" do
+    data_1 = new_data(:foo, {:type => Integer})
+    data_2 = new_data(:bar, {:type => Integer})
+
+    result_data = data_1.merge(data_2)
+    assert_equal(:foo_bar, result_data.name)
+    result_data = data_2.merge(data_1)
+    assert_equal(:bar_foo, result_data.name)
+  end
+
+  test "merge two boolean fields" do
+    data_1 = new_data(:foo, {:type => TrueClass})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => TrueClass}
+
+    result_data = data_1.merge(data_2)
+    assert_equal(:foo, result_data.name)
+    assert_equal(expected_type, result_data.ruby_type)
+
+    result_data = data_2.merge(data_1)
+    assert_equal(:foo, result_data.name)
+    assert_equal(expected_type, result_data.ruby_type)
+  end
+
+  test "merge a boolean field and an integer field" do
+    data_1 = new_data(:foo, {:type => Integer})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => Integer}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a bignum field" do
+    data_1 = new_data(:foo, {:type => Bignum})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => Bignum}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a float field" do
+    data_1 = new_data(:foo, {:type => Float})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => Float}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a decimal field" do
+    data_1 = new_data(:foo, {:type => BigDecimal})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a decimal field with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a boolean field and a fixed string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10, :fixed => true}})
+    data_2 = new_data(:foo, {:type => TrueClass})
+    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two integer fields" do
+    data_1 = new_data(:foo, {:type => Integer})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => Integer}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a bignum field" do
+    data_1 = new_data(:foo, {:type => Bignum})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => Bignum}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a float field" do
+    data_1 = new_data(:foo, {:type => Float})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => Float}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a decimal field" do
+    data_1 = new_data(:foo, {:type => BigDecimal})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a decimal field with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an integer field and a fixed string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10, :fixed => true}})
+    data_2 = new_data(:foo, {:type => Integer})
+    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two bignum fields" do
+    data_1 = new_data(:foo, {:type => Bignum})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => Bignum}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an bignum field and a decimal field" do
+    data_1 = new_data(:foo, {:type => BigDecimal})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an bignum field and a decimal field with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an bignum field and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an bignum field and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge an bignum field and a fixed string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10, :fixed => true}})
+    data_2 = new_data(:foo, {:type => Bignum})
+    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two float fields" do
+    data_1 = new_data(:foo, {:type => Float})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => Float}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a bignum field" do
+    data_1 = new_data(:foo, {:type => Bignum})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a decimal field" do
+    data_1 = new_data(:foo, {:type => BigDecimal})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a decimal field with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a float field and a fixed string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10, :fixed => true}})
+    data_2 = new_data(:foo, {:type => Float})
+    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two decimal fields" do
+    data_1 = new_data(:foo, {:type => BigDecimal})
+    data_2 = new_data(:foo, {:type => BigDecimal})
+    expected_type = {:type => BigDecimal}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two decimal fields, one with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => BigDecimal})
+    expected_type = {:type => BigDecimal, :opts => {:size => [10, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two decimal fields, both with size" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10, 2]}})
+    data_2 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [12, 1]}})
+    expected_type = {:type => BigDecimal, :opts => {:size => [12, 2]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two decimal fields, both with size, one without scale" do
+    data_1 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [10]}})
+    data_2 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [12, 1]}})
+    expected_type = {:type => BigDecimal, :opts => {:size => [12, 1]}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a decimal field and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => BigDecimal})
+    expected_type = {:type => String, :opts => {:size => 10}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a decimal field with size and a string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10}})
+    data_2 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [12, 2]}})
+    expected_type = {:type => String, :opts => {:size => 13}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a decimal field and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => BigDecimal})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a decimal field with size and a text field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:text => true}})
+    data_2 = new_data(:foo, {:type => BigDecimal, :opts => {:size => [12, 2]}})
+    expected_type = {:type => String, :opts => {:text => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge a decimal field and a fixed string field" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 10, :fixed => true}})
+    data_2 = new_data(:foo, {:type => BigDecimal})
+    expected_type = {:type => String, :opts => {:size => 10, :fixed => true}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two string fields" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 20}})
+    data_2 = new_data(:foo, {:type => String, :opts => {:size => 20}})
+    expected_type = {:type => String, :opts => {:size => 20}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two string fields with different sizes" do
+    data_1 = new_data(:foo, {:type => String, :opts => {:size => 15}})
+    data_2 = new_data(:foo, {:type => String, :opts => {:size => 20}})
+    expected_type = {:type => String, :opts => {:size => 20}}
+    assert_equal(expected_type, data_1.merge(data_2).ruby_type)
+    assert_equal(expected_type, data_2.merge(data_1).ruby_type)
+  end
+
+  test "merge two fields and specify name" do
+    data_1 = new_data(:id, {:type => Integer})
+    data_2 = new_data(:id, {:type => Integer})
+
+    result_data = data_1.merge(data_2, 'foo')
+    assert_equal :foo, result_data.name
+
+    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

data/test/unit/test_dataset.rb

@@ -15,9 +15,9 @@ class UnitTests::TestDataset < Test::Unit::TestCase
 
     @id_field = stub("id field", :dataset= => nil, :name => :id)
     Linkage::Field.stubs(:new).with(:id, kind_of(Hash)).returns(@id_field)
-    @first_name_field = stub("first_name field", :dataset= => nil, :name => :first_name)
+    @first_name_field = stub("first_name field", :dataset= => nil, :name => :first_name, :to_expr => :first_name)
     Linkage::Field.stubs(:new).with(:first_name, kind_of(Hash)).returns(@first_name_field)
-    @last_name_field = stub("last_name field", :dataset= => nil, :name => :last_name)
+    @last_name_field = stub("last_name field", :dataset= => nil, :name => :last_name, :to_expr => :last_name)
     Linkage::Field.stubs(:new).with(:last_name, kind_of(Hash)).returns(@last_name_field)
   end
 
@@ -107,8 +107,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert_empty dataset_2.instance_variable_get(:@filter)
   end
 
-  test "add_order, then each" do
-    field = stub('field', :name => :last_name)
+  test "add_order with field, then each" do
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_order(field)
     @dataset.expects(:order).with(:last_name).returns(@dataset)
@@ -123,8 +123,25 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert ran
   end
 
+  test "add_order with function, then each" do
+    expr = stub('expression')
+    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
+    ds = Linkage::Dataset.new("foo:/bar", "baz")
+    ds.add_order(func)
+    @dataset.expects(:order).with(expr).returns(@dataset)
+    row = {:id => 123, :trim_stuff => 'foo'}
+    @dataset.expects(:each).yields(row)
+
+    ran = false
+    ds.each do |yielded_row|
+      ran = true
+      assert_equal({:pk => 123, :values => {:trim_stuff => 'foo'}}, yielded_row)
+    end
+    assert ran
+  end
+
   test "add_order descending, then each" do
-    field = stub('field', :name => :last_name)
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_order(field, :desc)
     @dataset.expects(:order).with(:last_name.desc).returns(@dataset)
@@ -139,8 +156,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert ran
   end
 
-  test "add_order weeds out duplicates" do
-    field = stub('field', :name => :last_name)
+  test "add_order weeds out field duplicates" do
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_order(field)
     ds.add_order(field)
@@ -149,8 +166,19 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     ds.each { }
   end
 
-  test "add_select, then each" do
-    field = stub('field', :name => :last_name)
+  test "add_order weeds out function duplicates" do
+    expr = stub('expression')
+    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
+    ds = Linkage::Dataset.new("foo:/bar", "baz")
+    ds.add_order(func)
+    ds.add_order(func)
+    @dataset.expects(:order).with(expr).returns(@dataset)
+    @dataset.expects(:each)
+    ds.each { }
+  end
+
+  test "add_select with field, then each" do
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_select(field)
     @dataset.expects(:select).with(:id, :last_name).returns(@dataset)
@@ -166,7 +194,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_select with an alias, then each" do
-    field = stub('field', :name => :last_name)
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_select(field, :junk)
     @dataset.expects(:select).with(:id, :last_name.as(:junk)).returns(@dataset)
@@ -181,8 +209,25 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert ran
   end
 
+  test "add_select with function, then each" do
+    expr = stub('expression')
+    func = stub_function('func', :name => :trim_stuff, :to_expr => expr)
+    ds = Linkage::Dataset.new("foo:/bar", "baz")
+    ds.add_select(func)
+    @dataset.expects(:select).with(:id, expr).returns(@dataset)
+    row = {:id => 123, :trim_stuff => 'foo'}
+    @dataset.expects(:each).yields(row)
+
+    ran = false
+    ds.each do |yielded_row|
+      ran = true
+      assert_equal({:pk => 123, :values => {:trim_stuff => 'foo'}}, yielded_row)
+    end
+    assert ran
+  end
+
   test "add_select weeds out duplicates" do
-    field = stub('field', :name => :last_name)
+    field = stub_field('field', :name => :last_name, :to_expr => :last_name)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_select(field)
     ds.add_select(field)
@@ -191,8 +236,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     ds.each { }
   end
 
-  test "add_filter with :==, then each" do
-    field = stub('field', :name => :age)
+  test "add_filter with :== between field and static value, then each" do
+    field = stub('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :==, 30)
     @dataset.expects(:filter).with(:age => 30).returns(@dataset)
@@ -207,9 +252,27 @@ class UnitTests::TestDataset < Test::Unit::TestCase
     assert ran
   end
 
+  test "add_filter with :== between field and static function, then each" do
+    field = stub_field('field', :name => :age, :to_expr => :age)
+    expr = stub('expression')
+    func = stub_function('func', :name => :func, :to_expr => expr)
+    ds = Linkage::Dataset.new("foo:/bar", "baz")
+    ds.add_filter(field, :==, func)
+    @dataset.expects(:filter).with(:age => expr).returns(@dataset)
+    row = {:id => 123, :junk => 'foo'}
+    @dataset.expects(:each).yields(row)
+
+    ran = false
+    ds.each do |yielded_row|
+      ran = true
+      assert_equal({:pk => 123, :values => {:junk => 'foo'}}, yielded_row)
+    end
+    assert ran
+  end
+
   test "add_filter with :== between two fields, then each" do
-    field_1 = stub_field('field 1', :name => :foo)
-    field_2 = stub_field('field 2', :name => :bar)
+    field_1 = stub_field('field 1', :name => :foo, :to_expr => :foo)
+    field_2 = stub_field('field 2', :name => :bar, :to_expr => :bar)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field_1, :==, field_2)
     @dataset.expects(:filter).with(:foo => :bar).returns(@dataset)
@@ -218,7 +281,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :>, then each" do
-    field = stub('field', :name => :age)
+    field = stub('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :>, 30)
     @dataset.expects(:filter).with(expr{age > 30}).returns(@dataset)
@@ -227,7 +290,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :<, then each" do
-    field = stub('field', :name => :age)
+    field = stub_field('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :<, 30)
     @dataset.expects(:filter).with(expr{age < 30}).returns(@dataset)
@@ -236,7 +299,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :>=, then each" do
-    field = stub('field', :name => :age)
+    field = stub_field('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :>=, 30)
     @dataset.expects(:filter).with(expr{age >= 30}).returns(@dataset)
@@ -245,7 +308,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :<=, then each" do
-    field = stub('field', :name => :age)
+    field = stub('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :<=, 30)
     @dataset.expects(:filter).with(expr{age <= 30}).returns(@dataset)
@@ -254,7 +317,7 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :!=, then each" do
-    field = stub('field', :name => :age)
+    field = stub_field('field', :name => :age, :to_expr => :age)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field, :'!=', 30)
     @dataset.expects(:filter).with(~{:age => 30}).returns(@dataset)
@@ -263,8 +326,8 @@ class UnitTests::TestDataset < Test::Unit::TestCase
   end
 
   test "add_filter with :> field, then each" do
-    field_1 = stub_field('field 1', :name => :age)
-    field_2 = stub_field('field 2', :name => :age_2)
+    field_1 = stub_field('field 1', :name => :age, :to_expr => :age)
+    field_2 = stub_field('field 2', :name => :age_2, :to_expr => :age_2)
     ds = Linkage::Dataset.new("foo:/bar", "baz")
     ds.add_filter(field_1, :>, field_2)
     @dataset.expects(:filter).with(expr{age > age_2}).returns(@dataset)