linkage 0.0.8 → 0.1.0.pre

data/test/unit/expectations/test_exhaustive.rb

@@ -1,111 +0,0 @@
-require 'helper'
-
-class UnitTests::TestExhaustive < Test::Unit::TestCase
-  test "initialize with comparator, threshold, and mode" do
-    comparator = stub('comparator')
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal comparator, exp.comparator
-    assert_equal 100, exp.threshold
-    assert_equal :min, exp.mode
-  end
-
-  test "kind is :self when comparator has same args on both sides" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(true)
-    comparator = stub('comparator', {
-      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
-    })
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal :self, exp.kind
-  end
-
-  test "kind is :cross when comparator has args with same dataset but different number of args" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    meta_object_3 = stub('meta object 3')
-    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(true)
-    comparator = stub('comparator', {
-      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2, meta_object_3]
-    })
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal :cross, exp.kind
-  end
-
-  test "kind is :cross when comparator has args with same dataset but different objects" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(false)
-    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(true)
-    comparator = stub('comparator', {
-      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
-    })
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal :cross, exp.kind
-  end
-
-  test "kind is :dual when comparator has args with different datasets and different number of args" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    meta_object_3 = stub('meta object 3')
-    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(false)
-    comparator = stub('comparator', {
-      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2, meta_object_3]
-    })
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal :dual, exp.kind
-  end
-
-  test "kind is :dual when comparator has args with different datasets" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    meta_object_1.expects(:objects_equal?).with(meta_object_2).returns(false)
-    meta_object_1.expects(:datasets_equal?).with(meta_object_2).returns(false)
-    comparator = stub('comparator', {
-      :lhs_args => [meta_object_1], :rhs_args => [meta_object_2]
-    })
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    assert_equal :dual, exp.kind
-  end
-
-  test "apply_to lhs dataset" do
-    dataset = stub('dataset')
-    new_dataset = stub('new dataset')
-    meta_object_1 = stub('meta object 1', :name => :foo, :to_expr => :foo)
-    meta_object_2 = stub('meta object 2', :name => :bar, :to_expr => :bar)
-    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    dataset.expects(:select_more).with(:foo.as(:foo)).returns(new_dataset)
-    assert_equal new_dataset, exp.apply_to(dataset, :lhs)
-  end
-
-  test "apply_to rhs dataset" do
-    dataset = stub('dataset')
-    new_dataset = stub('new dataset')
-    meta_object_1 = stub('meta object 1', :name => :foo, :to_expr => :foo)
-    meta_object_2 = stub('meta object 2', :name => :bar, :to_expr => :bar)
-    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 100, :min)
-    dataset.expects(:select_more).with(:bar.as(:bar)).returns(new_dataset)
-    assert_equal new_dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "satisfied? with :equal mode" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 50, :equal)
-    assert exp.satisfied?(50)
-    assert !exp.satisfied?(123)
-  end
-
-  test "satisfied? with :min mode" do
-    meta_object_1 = stub('meta object 1')
-    meta_object_2 = stub('meta object 2')
-    comparator = stub('comparator', :lhs_args => [meta_object_1], :rhs_args => [meta_object_2])
-    exp = Linkage::Expectations::Exhaustive.new(comparator, 50, :min)
-    assert exp.satisfied?(50)
-    assert exp.satisfied?(55)
-    assert !exp.satisfied?(45)
-  end
-end

data/test/unit/expectations/test_simple.rb

@@ -1,303 +0,0 @@
-require 'helper'
-
-class UnitTests::TestSimple < Test::Unit::TestCase
-  test "initialize with invalid operator" do
-    assert_raises(ArgumentError) do
-      Linkage::Expectations::Simple.new(stub(), stub(), :foo)
-    end
-  end
-
-  test "creating filter expectation from a dynamic object and a static object" do
-    field = stub('meta field', :static? => false, :side => :lhs)
-    object = stub('meta object', :static? => true)
-    exp = Linkage::Expectations::Simple.create(field, object, :==)
-    assert_kind_of Linkage::Expectations::Filter, exp
-    assert_equal :lhs, exp.side
-  end
-
-  test "creating expectation from two static objects raises error" do
-    object_1 = stub('meta object 1', :static? => true)
-    object_2 = stub('meta object 2', :static? => true)
-    assert_raises(ArgumentError) do
-      Linkage::Expectations::Simple.create(object_1, object_2, :==)
-    end
-  end
-
-  test "creating filter expectation from two dynamic objects with the same side" do
-    field_1 = stub('meta field 1', :static? => false, :side => :lhs)
-    field_2 = stub('meta field 2', :static? => false, :side => :lhs)
-    field_1.expects(:datasets_equal?).with(field_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(field_1, field_2, :==)
-    assert_kind_of Linkage::Expectations::Filter, exp
-    assert_equal :lhs, exp.side
-  end
-
-  test "creating filter expectation from two dynamic objects with the same side but different datasets raises error" do
-    field_1 = stub('meta field 1', :static? => false, :side => :lhs)
-    field_2 = stub('meta field 2', :static? => false, :side => :lhs)
-    field_1.expects(:datasets_equal?).with(field_2).returns(false)
-    assert_raises(ArgumentError) do
-      Linkage::Expectations::Simple.create(field_1, field_2, :==)
-    end
-  end
-
-  test "creating self expectation from two dynamic objects with different sides" do
-    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
-    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
-    object_1.expects(:objects_equal?).with(object_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-    assert_kind_of Linkage::Expectations::Self, exp
-  end
-
-  test "creating cross expectation from two dynamic objects with different sides but same dataset" do
-    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
-    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
-    object_1.expects(:objects_equal?).with(object_2).returns(false)
-    object_1.expects(:datasets_equal?).with(object_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-    assert_kind_of Linkage::Expectations::Cross, exp
-  end
-
-  test "creating dual expectation from two dynamic objects with different sides and datasets" do
-    object_1 = stub('meta object 1', :static? => false, :side => :lhs)
-    object_2 = stub('meta object 2', :static? => false, :side => :rhs)
-    object_1.expects(:objects_equal?).with(object_2).returns(false)
-    object_1.expects(:datasets_equal?).with(object_2).returns(false)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-    assert_kind_of Linkage::Expectations::Dual, exp
-  end
-
-  test "apply_to with filter expectation (== operator)" do
-    dataset = stub('dataset')
-    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
-    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
-    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
-
-    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :==)
-    meta_field_1.expects(:to_expr).returns(:foo)
-    meta_field_2.expects(:to_expr).returns(:bar)
-    dataset.expects(:filter).with({:foo => :bar}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :lhs)
-
-    dataset.expects(:filter).never
-    assert_equal dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "apply_to with filter expectation (!= operator)" do
-    dataset = stub('dataset')
-    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
-    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
-    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
-
-    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :'!=')
-    meta_field_1.expects(:to_expr).returns(:foo)
-    meta_field_2.expects(:to_expr).returns(:bar)
-    dataset.expects(:filter).with(~{:foo => :bar}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :lhs)
-
-    dataset.expects(:filter).never
-    assert_equal dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "apply_to with filter expectation (> operator)" do
-    dataset = stub('dataset')
-    meta_field_1 = stub('meta field 1', :static? => false, :side => :lhs)
-    meta_field_2 = stub('meta field 2', :static? => false, :side => :lhs)
-    meta_field_1.stubs(:datasets_equal?).with(meta_field_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(meta_field_1, meta_field_2, :>)
-
-    identifier_1 = Sequel::SQL::Identifier.new(:foo)
-    meta_field_1.expects(:to_identifier).returns(identifier_1)
-    identifier_2 = Sequel::SQL::Identifier.new(:bar)
-    meta_field_2.expects(:to_identifier).returns(identifier_2)
-    expected = Sequel::SQL::BooleanExpression.new(:>, identifier_1, identifier_2)
-
-    dataset.expects(:filter).with(expected).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :lhs)
-
-    dataset.expects(:filter).never
-    assert_equal dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "apply_to with self expectation" do
-    dataset = stub('dataset')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset,
-      :to_expr => :foo
-    })
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset,
-      :to_expr => :foo
-    })
-    object_1.expects(:objects_equal?).with(object_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-
-    merged_field = stub('merged field', :name => :foo)
-    object_1.expects(:merge).with(object_2).returns(merged_field)
-    dataset.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :lhs)
-
-    dataset.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "apply_to with cross expectation" do
-    dataset = stub('dataset')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset,
-      :to_expr => :foo
-    })
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset,
-      :to_expr => :bar
-    })
-    object_1.stubs(:objects_equal?).with(object_2).returns(false)
-    object_1.stubs(:datasets_equal?).with(object_2).returns(true)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-
-    merged_field = stub('merged field', :name => :foo_bar)
-    object_1.expects(:merge).with(object_2).returns(merged_field)
-    dataset.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo_bar}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :lhs)
-
-    dataset.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo_bar}).returns(dataset)
-    assert_equal dataset, exp.apply_to(dataset, :rhs)
-  end
-
-  test "apply_to with dual expectation" do
-    dataset_1 = stub('dataset 1')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset_1,
-      :to_expr => :foo
-    })
-    dataset_2 = stub('dataset 2')
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset_2,
-      :to_expr => :foo
-    })
-    object_1.stubs(:objects_equal?).with(object_2).returns(false)
-    object_1.stubs(:datasets_equal?).with(object_2).returns(false)
-    exp = Linkage::Expectations::Simple.create(object_1, object_2, :==)
-
-    merged_field = stub('merged field', :name => :foo)
-    object_1.expects(:merge).with(object_2).returns(merged_field)
-    dataset_1.expects(:group_match_more).with({:meta_object => object_1, :alias => :foo}).returns(dataset_1)
-    assert_equal dataset_1, exp.apply_to(dataset_1, :lhs)
-
-    dataset_2.expects(:group_match_more).with({:meta_object => object_2, :alias => :foo}).returns(dataset_2)
-    assert_equal dataset_2, exp.apply_to(dataset_2, :rhs)
-  end
-
-  test "exactly! wraps each side inside the binary function" do
-    dataset_1 = stub('dataset 1')
-    field_1 = stub_field('field 1', :dataset => dataset_1)
-    meta_object_1 = stub('meta object 1', :static? => false, :side => :lhs,
-                         :object => field_1, :dataset => dataset_1)
-
-    dataset_2 = stub('dataset 2')
-    field_2 = stub_field('field 2', :dataset => dataset_2)
-    meta_object_2 = stub('meta object 2', :static? => false, :side => :rhs,
-                         :object => field_2, :dataset => dataset_2)
-    meta_object_1.stubs(:objects_equal?).with(meta_object_2).returns(true)
-
-    exp = Linkage::Expectations::Simple.create(meta_object_1, meta_object_2, :==)
-
-    klass = Linkage::Functions::Binary
-    func_1 = stub('binary function 1')
-    klass.expects(:new).with(field_1, :dataset => dataset_1).returns(func_1)
-    func_2 = stub('binary function 2')
-    klass.expects(:new).with(field_2, :dataset => dataset_2).returns(func_2)
-
-    new_meta_object_1 = stub('new meta object 1')
-    Linkage::MetaObject.expects(:new).with(func_1, :lhs).returns(new_meta_object_1)
-    new_meta_object_2 = stub('new meta object 2')
-    Linkage::MetaObject.expects(:new).with(func_2, :rhs).returns(new_meta_object_2)
-
-    exp.exactly!
-    # LAZY: assume the expectation set its meta objects appropriately
-  end
-
-  test "#same_except_side with two filter expectations" do
-    field = stub_field('foo')
-    meta_object_1 = stub('meta field 1', {
-      :static? => false, :side => :lhs, :object => field
-    })
-    meta_object_2 = stub('meta object', :static? => true)
-    meta_object_3 = stub('meta field 2', {
-      :static? => false, :side => :rhs, :object => field
-    })
-
-    exp_1 = Linkage::Expectations::Simple.create(meta_object_1, meta_object_2, :==)
-    exp_2 = Linkage::Expectations::Simple.create(meta_object_3, meta_object_2, :==)
-
-    meta_object_1.expects(:objects_equal?).with(meta_object_3).returns(true)
-    meta_object_2.expects(:objects_equal?).with(meta_object_2).returns(true)
-    assert exp_1.same_except_side?(exp_2)
-  end
-
-  test "#decollation_needed? is false when comparing non-string objects" do
-    dataset_1 = stub('dataset 1')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset_1,
-    })
-    dataset_2 = stub('dataset 2')
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset_2,
-    })
-    merged_field = stub('merged field', :ruby_type => {:type => Fixnum})
-    object_1.stubs(:merge).with(object_2).returns(merged_field)
-    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
-    assert !exp.decollation_needed?
-  end
-
-  test "#decollation_needed? is false when comparing two dynamic string objects with the same database type and same collation" do
-    dataset_1 = stub('dataset 1')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset_1,
-      :collation => 'foo', :database_type => :mysql
-    })
-    dataset_2 = stub('dataset 2')
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset_2,
-      :collation => 'foo', :database_type => :mysql
-    })
-    merged_field = stub('merged field', :ruby_type => {:type => String})
-    object_1.stubs(:merge).with(object_2).returns(merged_field)
-    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
-    assert !exp.decollation_needed?
-  end
-
-  test "#decollation_needed? is true when comparing two dynamic string objects with the same database type but different collations" do
-    dataset_1 = stub('dataset 1')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset_1,
-      :collation => 'foo', :database_type => :mysql
-    })
-    dataset_2 = stub('dataset 2')
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset_2,
-      :collation => 'bar', :database_type => :mysql
-    })
-    merged_field = stub('merged field', :ruby_type => {:type => String})
-    object_1.stubs(:merge).with(object_2).returns(merged_field)
-    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
-    assert exp.decollation_needed?
-  end
-
-  test "#decollation_needed? is true when comparing two dynamic string objects with same collation but different database types" do
-    dataset_1 = stub('dataset 1')
-    object_1 = stub('meta object 1', {
-      :static? => false, :side => :lhs, :dataset => dataset_1,
-      :collation => 'foo', :database_type => :foo
-    })
-    dataset_2 = stub('dataset 2')
-    object_2 = stub('meta object 2', {
-      :static? => false, :side => :rhs, :dataset => dataset_2,
-      :collation => 'foo', :database_type => :bar
-    })
-    merged_field = stub('merged field', :ruby_type => {:type => String})
-    object_1.stubs(:merge).with(object_2).returns(merged_field)
-    exp = Linkage::Expectations::Dual.new(object_1, object_2, :==)
-    assert exp.decollation_needed?
-  end
-end

data/test/unit/functions/test_binary.rb

@@ -1,54 +0,0 @@
-require 'helper'
-
-class UnitTests::TestBinary < Test::Unit::TestCase
-  def self.const_missing(name)
-    if Linkage::Functions.const_defined?(name)
-      Linkage::Functions.const_get(name)
-    else
-      super
-    end
-  end
-
-  test "subclass of Function" do
-    assert_equal Linkage::Function, Linkage::Functions::Binary.superclass
-  end
-
-  test "ruby_type" do
-    expected = {:type => File}
-    assert_equal(expected, Linkage::Functions::Binary.new("foo", :dataset => stub('dataset')).ruby_type)
-    field = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    assert_equal(expected, Linkage::Functions::Binary.new(field).ruby_type)
-  end
-
-  test "parameters" do
-    assert_equal [[String]], Linkage::Functions::Binary.parameters
-  end
-
-  test "name" do
-    assert_equal "binary", Linkage::Functions::Binary.function_name
-  end
-
-  test "registers itself" do
-    assert_equal Linkage::Function["binary"], Linkage::Functions::Binary
-  end
-
-  test "requires dataset" do
-    func = Binary.new("foo")
-    assert_raises(RuntimeError) { func.to_expr }
-  end
-
-  test "to_expr for sqlite" do
-    func = Binary.new("foo", :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal "foo".cast(:blob), func.to_expr
-  end
-
-  test "to_expr for mysql" do
-    func = Binary.new("foo", :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal "foo".cast(:binary), func.to_expr
-  end
-
-  test "to_expr for postgresql" do
-    func = Binary.new("foo", :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal "foo".cast(:bytea), func.to_expr
-  end
-end

data/test/unit/functions/test_cast.rb

@@ -1,98 +0,0 @@
-require 'helper'
-
-class UnitTests::TestCast < Test::Unit::TestCase
-  def self.const_missing(name)
-    if Linkage::Functions.const_defined?(name)
-      Linkage::Functions.const_get(name)
-    else
-      super
-    end
-  end
-
-  test "subclass of Function" do
-    assert_equal Linkage::Function, Linkage::Functions::Cast.superclass
-  end
-
-  test "parameters" do
-    assert_equal [[:any], [String]], Linkage::Functions::Cast.parameters
-  end
-
-  test "name" do
-    assert_equal "cast", Linkage::Functions::Cast.function_name
-  end
-
-  test "ruby_type when casting to (signed) integer" do
-    expected = {:type => Fixnum}
-    assert_equal(expected, Linkage::Functions::Cast.new('123', 'integer', :dataset => stub('dataset')).ruby_type)
-    field = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    assert_equal(expected, Linkage::Functions::Cast.new(field, 'integer').ruby_type)
-  end
-
-  test "ruby_type when casting to binary" do
-    expected = {:type => File}
-    assert_equal(expected, Linkage::Functions::Cast.new('123', 'binary', :dataset => stub('dataset')).ruby_type)
-    field = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    assert_equal(expected, Linkage::Functions::Cast.new(field, 'binary').ruby_type)
-  end
-
-  test "registers itself" do
-    assert_equal Linkage::Function["cast"], Linkage::Functions::Cast
-  end
-
-  test "to_expr for integer (sqlite)" do
-    func = Cast.new('foo', 'integer', :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal 'foo'.cast(:integer), func.to_expr
-  end
-
-  test "to_expr for integer (mysql)" do
-    func = Cast.new('foo', 'integer', :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal 'foo'.cast(:signed), func.to_expr
-  end
-
-  test "to_expr for integer (postgres)" do
-    func = Cast.new('foo', 'integer', :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal 'foo'.cast(:integer), func.to_expr
-  end
-
-  test "to_expr for integer (h2)" do
-    func = Cast.new('foo', 'integer', :dataset => stub('dataset', :database_type => :h2))
-    assert_equal 'foo'.cast(:integer), func.to_expr
-  end
-
-  test "to_expr for binary (sqlite)" do
-    func = Cast.new('foo', 'binary', :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal 'foo'.cast(:blob), func.to_expr
-  end
-
-  test "to_expr for binary (mysql)" do
-    func = Cast.new('foo', 'binary', :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal 'foo'.cast(:binary), func.to_expr
-  end
-
-  test "to_expr for binary (postgres)" do
-    func = Cast.new('foo', 'binary', :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal 'foo'.cast(:bytea), func.to_expr
-  end
-
-  test "to_expr for binary (h2)" do
-    func = Cast.new('foo', 'binary', :dataset => stub('dataset', :database_type => :h2))
-    assert_equal 'foo'.cast(:binary), func.to_expr
-  end
-
-=begin
-  test "to_expr for sqlite" do
-    func = Cast.new("foo", :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal "foo".cast(:blob), func.to_expr
-  end
-
-  test "to_expr for mysql" do
-    func = Cast.new("foo", :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal "foo".cast(:binary), func.to_expr
-  end
-
-  test "to_expr for postgresql" do
-    func = Cast.new("foo", :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal "foo".cast(:bytea), func.to_expr
-  end
-=end
-end

data/test/unit/functions/test_length.rb

@@ -1,52 +0,0 @@
-require 'helper'
-
-class UnitTests::TestLength < Test::Unit::TestCase
-  test "subclass of Function" do
-    assert_equal Linkage::Function, Linkage::Functions::Length.superclass
-  end
-
-  test "ruby_type for string literal" do
-    length = Linkage::Functions::Length.new("foo", :dataset => stub('dataset'))
-    assert_equal({:type => Fixnum}, length.ruby_type)
-  end
-
-  test "ruby_type for string field" do
-    field_1 = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    assert_equal({:type => Fixnum}, Linkage::Functions::Length.new(field_1).ruby_type)
-
-    field_2 = stub_field('field 2', :name => :bar, :ruby_type => {:type => String, :opts => {:size => 123}}, :dataset => stub('dataset'))
-    assert_equal({:type => Fixnum}, Linkage::Functions::Length.new(field_2).ruby_type)
-  end
-
-  test "ruby_type for string function" do
-    func = new_function('foo', {:type => String, :opts => {:junk => '123'}})
-    assert_equal({:type => Fixnum}, Linkage::Functions::Length.new(func.new(:dataset => stub('dataset'))).ruby_type)
-  end
-
-  test "parameters" do
-    assert_equal [[String]], Linkage::Functions::Length.parameters
-  end
-
-  test "name" do
-    assert_equal "length", Linkage::Functions::Length.function_name
-  end
-
-  test "to_expr for sqlite" do
-    func = Linkage::Functions::Length.new("foo bar", :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal :length.sql_function("foo bar"), func.to_expr
-  end
-
-  test "to_expr for mysql" do
-    func = Linkage::Functions::Length.new("foo bar", :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal :char_length.sql_function("foo bar"), func.to_expr
-  end
-
-  test "to_expr for postgresql" do
-    func = Linkage::Functions::Length.new("foo bar", :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal :char_length.sql_function("foo bar"), func.to_expr
-  end
-
-  test "registers itself" do
-    assert_equal Linkage::Function["length"], Linkage::Functions::Length
-  end
-end

data/test/unit/functions/test_strftime.rb

@@ -1,60 +0,0 @@
-require 'helper'
-
-class UnitTests::TestStrftime < Test::Unit::TestCase
-  def self.const_missing(name)
-    if Linkage::Functions.const_defined?(name)
-      Linkage::Functions.const_get(name)
-    else
-      super
-    end
-  end
-
-  test "subclass of Function" do
-    assert_equal Linkage::Function, Linkage::Functions::Strftime.superclass
-  end
-
-  test "ruby_type" do
-    expected = {:type => String}
-    format = "%Y-%m-%d"
-    assert_equal(expected, Linkage::Functions::Strftime.new(Time.now, format, :dataset => stub('dataset')).ruby_type)
-    field = stub_field('field 1', :name => :bar, :ruby_type => {:type => Time})
-    assert_equal(expected, Linkage::Functions::Strftime.new(field, format, :dataset => stub('dataset')).ruby_type)
-    func = new_function('foo', {:type => Time, :opts => {:junk => '123'}})
-    assert_equal(expected, Linkage::Functions::Strftime.new(func.new(:dataset => stub('dataset')), format).ruby_type)
-  end
-
-  test "parameters" do
-    assert_equal [[Date, Time, DateTime], [String]], Linkage::Functions::Strftime.parameters
-  end
-
-  test "name" do
-    assert_equal "strftime", Linkage::Functions::Strftime.function_name
-  end
-
-  test "registers itself" do
-    assert_equal Linkage::Function["strftime"], Linkage::Functions::Strftime
-  end
-
-  test "requires dataset" do
-    func = Strftime.new(Time.now, "%Y-%m-%d")
-    assert_raises(RuntimeError) { func.to_expr }
-  end
-
-  test "to_expr for sqlite" do
-    now = Time.now
-    func = Strftime.new(now, "%Y-%m-%d", :dataset => stub('dataset', :database_type => :sqlite))
-    assert_equal :strftime.sql_function("%Y-%m-%d", now), func.to_expr
-  end
-
-  test "to_expr for mysql" do
-    now = Time.now
-    func = Strftime.new(now, "%Y-%m-%d", :dataset => stub('dataset', :database_type => :mysql))
-    assert_equal :date_format.sql_function(now, "%Y-%m-%d"), func.to_expr
-  end
-
-  test "to_expr for postgresql" do
-    now = Time.now
-    func = Strftime.new(now, "%Y-%m-%d", :dataset => stub('dataset', :database_type => :postgres))
-    assert_equal :to_char.sql_function(now, "%Y-%m-%d"), func.to_expr
-  end
-end