linkage 0.0.6 → 0.0.8

data/test/unit/functions/test_binary.rb

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,98 @@
+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

@@ -0,0 +1,52 @@
+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

@@ -16,11 +16,11 @@ class UnitTests::TestStrftime < Test::Unit::TestCase
   test "ruby_type" do
     expected = {:type => String}
     format = "%Y-%m-%d"
-    assert_equal(expected, Linkage::Functions::Strftime.new(Time.now, format).ruby_type)
+    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).ruby_type)
+    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, format).ruby_type)
+    assert_equal(expected, Linkage::Functions::Strftime.new(func.new(:dataset => stub('dataset')), format).ruby_type)
   end
 
   test "parameters" do
@@ -35,22 +35,26 @@ class UnitTests::TestStrftime < Test::Unit::TestCase
     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
-    args = [Time.now, "%Y-%m-%d"]
-    func = Strftime.new(*args)
-    assert_equal :strftime.sql_function(args[1], args[0]), func.to_expr(:sqlite)
+    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
-    args = [Time.now, "%Y-%m-%d"]
-    func = Strftime.new(*args)
-    assert_equal :date_format.sql_function(*args), func.to_expr(:mysql)
-    assert_equal :date_format.sql_function(*args), func.to_expr(:mysql2)
+    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
-    args = [Time.now, "%Y-%m-%d"]
-    func = Strftime.new(*args)
-    assert_equal :to_char.sql_function(*args), func.to_expr(:postgres)
+    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

data/test/unit/functions/test_trim.rb

@@ -6,20 +6,21 @@ class UnitTests::TestTrim < Test::Unit::TestCase
   end
 
   test "ruby_type for string literal" do
-    assert_equal({:type => String}, Linkage::Functions::Trim.new("foo").ruby_type)
+    trim = Linkage::Functions::Trim.new("foo", :dataset => stub('dataset'))
+    assert_equal({:type => String}, trim.ruby_type)
   end
 
   test "ruby_type for string field" do
-    field_1 = stub_field('field 1', :name => :bar, :ruby_type => {:type => String})
+    field_1 = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
     assert_equal({:type => String}, Linkage::Functions::Trim.new(field_1).ruby_type)
 
-    field_2 = stub_field('field 2', :name => :bar, :ruby_type => {:type => String, :opts => {:size => 123}})
+    field_2 = stub_field('field 2', :name => :bar, :ruby_type => {:type => String, :opts => {:size => 123}}, :dataset => stub('dataset'))
     assert_equal({:type => String, :opts => {:size => 123}}, Linkage::Functions::Trim.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 => String, :opts => {:junk => '123'}}, Linkage::Functions::Trim.new(func.new).ruby_type)
+    assert_equal({:type => String, :opts => {:junk => '123'}}, Linkage::Functions::Trim.new(func.new(:dataset => stub('dataset'))).ruby_type)
   end
 
   test "parameters" do
@@ -33,4 +34,10 @@ class UnitTests::TestTrim < Test::Unit::TestCase
   test "registers itself" do
     assert_equal Linkage::Function["trim"], Linkage::Functions::Trim
   end
+
+  test "collation returns argument collation if it exists" do
+    field_1 = stub_field('field 1', :name => :bar, :ruby_type => {:type => String}, :collation => 'foo', :dataset => stub('dataset'))
+    trim = Linkage::Functions::Trim.new(field_1)
+    assert_equal 'foo', trim.collation
+  end
 end

data/test/unit/test_comparator.rb

@@ -0,0 +1,124 @@
+require 'helper'
+
+class UnitTests::TestComparator < Test::Unit::TestCase
+  def setup
+    super
+    @_comparators = Linkage::Comparator.instance_variable_get("@comparators")
+  end
+
+  def teardown
+    Linkage::Comparator.instance_variable_set("@comparators", @_comparators)
+    super
+  end
+
+  test "comparator_name raises error in base class" do
+    assert_raises(NotImplementedError) { Linkage::Comparator.comparator_name }
+  end
+
+  test "registering subclass requires comparator_name" do
+    klass = Class.new(Linkage::Comparator)
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "getting a registered subclass" do
+    klass = new_comparator('foo', [[String]], 0..1)
+    Linkage::Comparator.register(klass)
+    assert_equal klass, Linkage::Comparator['foo']
+  end
+
+  test "parameters raises error in base class" do
+    assert_raises(NotImplementedError) { Linkage::Comparator.parameters }
+  end
+
+  test "subclasses required to define parameters class method" do
+    klass = new_comparator('foo')
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "subclasses required to define at least one parameter" do
+    klass = new_comparator('foo', [])
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "subclasses required to define score_range class method" do
+    klass = new_comparator('foo', [[String]])
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "score_range class should be a Range of two numbers" do
+    klass = new_comparator('foo', [[String]], "foo".."bar")
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "subclasses required to define score method" do
+    klass = new_comparator('foo', [[String]]) do
+      remove_method :score
+    end
+    assert_raises(ArgumentError) { Linkage::Comparator.register(klass) }
+  end
+
+  test "comparator with one valid argument" do
+    klass = new_comparator('foo', [[String]])
+    meta_object = stub('meta object', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
+    f = klass.new(meta_object)
+  end
+
+  test "comparator with one invalid argument" do
+    klass = new_comparator('foo', [[String]])
+    meta_object = stub('meta_object', :ruby_type => { :type => Fixnum }, :static? => false)
+    assert_raises(TypeError) { klass.new(meta_object) }
+  end
+
+  test "comparator with too few arguments" do
+    klass = new_comparator('foo', [[String]])
+    assert_raises(ArgumentError) { klass.new }
+  end
+
+  test "comparator with too many arguments" do
+    klass = new_comparator('foo', [[String]])
+    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => false)
+    assert_raises(ArgumentError) { klass.new(meta_object, meta_object) }
+  end
+
+  test "requiring argument to be non-static" do
+    klass = new_comparator('foo', [[String, :static => false]])
+    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => true)
+    assert_raise_message("argument 1 was expected to not be static") do
+      klass.new(meta_object)
+    end
+  end
+
+  test "requiring argument to be static" do
+    klass = new_comparator('foo', [[String, :static => true]])
+    meta_object = stub('meta_object', :ruby_type => { :type => String }, :static? => false)
+    assert_raise_message("argument 1 was expected to be static") do
+      klass.new(meta_object)
+    end
+  end
+
+  test "special :any parameter" do
+    klass = new_comparator('foo', [[:any]])
+    meta_object_1 = stub('meta_object', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
+    meta_object_2 = stub('meta_object', :side => :rhs, :ruby_type => { :type => Fixnum }, :static? => false)
+    assert_nothing_raised do
+      klass.new(meta_object_1)
+      klass.new(meta_object_2)
+    end
+  end
+
+  test "lhs_args" do
+    klass = new_comparator('foo', [[String], [String]])
+    meta_object_1 = stub('meta object 1', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
+    meta_object_2 = stub('meta object 2', :side => :rhs, :ruby_type => { :type => String }, :static? => false)
+    obj = klass.new(meta_object_1, meta_object_2)
+    assert_equal [meta_object_1], obj.lhs_args
+  end
+
+  test "rhs_args" do
+    klass = new_comparator('foo', [[String], [String]])
+    meta_object_1 = stub('meta object 1', :side => :lhs, :ruby_type => { :type => String }, :static? => false)
+    meta_object_2 = stub('meta object 2', :side => :rhs, :ruby_type => { :type => String }, :static? => false)
+    obj = klass.new(meta_object_1, meta_object_2)
+    assert_equal [meta_object_2], obj.rhs_args
+  end
+end