linkage 0.0.8 → 0.1.0.pre

data/test/unit/functions/test_trim.rb

@@ -1,43 +0,0 @@
-require 'helper'
-
-class UnitTests::TestTrim < Test::Unit::TestCase
-  test "subclass of Function" do
-    assert_equal Linkage::Function, Linkage::Functions::Trim.superclass
-  end
-
-  test "ruby_type for string literal" do
-    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}, :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}}, :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(:dataset => stub('dataset'))).ruby_type)
-  end
-
-  test "parameters" do
-    assert_equal [[String]], Linkage::Functions::Trim.parameters
-  end
-
-  test "name" do
-    assert_equal "trim", Linkage::Functions::Trim.function_name
-  end
-
-  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/runner/test_single_threaded.rb

@@ -1,12 +0,0 @@
-require 'helper'
-
-class UnitTests::TestSingleThreadedRunner < Test::Unit::TestCase
-  test "subclass of Runner" do
-    assert_equal Linkage::Runner, Linkage::SingleThreadedRunner.superclass
-  end
-
-  test "defines execute" do
-    methods = Linkage::SingleThreadedRunner.public_instance_methods(false)
-    assert methods.include?(:execute) || methods.include?("execute")
-  end
-end

data/test/unit/test_data.rb

@@ -1,445 +0,0 @@
-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 "to_expr raises NotImplementedError" do
-    d = Linkage::Data.new(:foo)
-    assert_raises(NotImplementedError) { d.to_expr }
-  end
-
-  test "database_type" do
-    dataset = mock('dataset')
-    data_1 = new_data(:foo, {}, dataset)
-    dataset.expects(:database_type).returns(:mysql)
-    assert_equal :mysql, data_1.database_type
-  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 "merge a string field and a date field" do
-    data_1 = new_data(:foo, {:type => String})
-    data_2 = new_data(:foo, {:type => Date})
-    assert_raises { data_1.merge(data_2).ruby_type }
-  end
-
-  test "merging two string fields with different collations strips the collation" do
-    dataset_1 = stub('dataset 1', :database_type => :mysql)
-    data_1 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_1)
-    dataset_2 = stub('dataset 2', :database_type => :mysql)
-    data_2 = new_data(:foo, {:type => String, :opts => {:collate => :bar}}, dataset_2)
-
-    result_data = data_1.merge(data_2)
-    result_opts = result_data.ruby_type[:opts] || {}
-    assert_nil result_opts[:collate]
-  end
-
-  test "merging two string fields with different database types strips the collation" do
-    dataset_1 = stub('dataset 1', :database_type => :mysql)
-    data_1 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_1)
-    dataset_2 = stub('dataset 2', :database_type => :sqlite)
-    data_2 = new_data(:foo, {:type => String, :opts => {:collate => :foo}}, dataset_2)
-
-    result_data = data_1.merge(data_2)
-    result_opts = result_data.ruby_type[:opts] || {}
-    assert_nil result_opts[:collate]
-  end
-
-  test "merged field has database type if they're the same" do
-    dataset_1 = stub('dataset 1', :database_type => :mysql)
-    data_1 = new_data(:foo, {:type => String}, dataset_1)
-    dataset_2 = stub('dataset 2', :database_type => :mysql)
-    data_2 = new_data(:foo, {:type => String}, dataset_2)
-    result_data = data_1.merge(data_2)
-    assert_equal :mysql, result_data.database_type
-  end
-
-  test "collation returns nil by default" do
-    dataset = stub('dataset')
-    data = new_data(:foo, {:type => String}, dataset)
-    assert_nil data.collation
-  end
-end