linkage 0.0.8 → 0.1.0.pre

data/test/unit/test_decollation.rb

@@ -1,201 +0,0 @@
-# encoding: utf-8
-require 'helper'
-
-class UnitTests::TestDecollation < Test::Unit::TestCase
-  include Linkage::Decollation
-
-  test "mysql's latin1_swedish_ci handles 'A' letters" do
-    # MySQL 6.0.4 collation (http://www.collation-charts.org/mysql60/mysql604.latin1_swedish_ci.html)
-    ["A", "a", "À", "Á", "Â", "Ã", "à", "á", "â", "ã"].each do |chr|
-      assert_equal "A", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'B' letters" do
-    ["B", "b"].each do |chr|
-      assert_equal "B", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'C' letters" do
-    ["C", "c", "Ç", "ç"].each do |chr|
-      assert_equal "C", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'D' letters" do
-    ["D", "d", "Ð", "ð"].each do |chr|
-      assert_equal "D", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'E' letters" do
-    ["E", "e", "È", "É", "Ê", "Ë", "è", "é", "ê", "ë"].each do |chr|
-      assert_equal "E", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'F' letters" do
-    ["F", "f"].each do |chr|
-      assert_equal "F", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'G' letters" do
-    ["G", "g"].each do |chr|
-      assert_equal "G", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'H' letters" do
-    ["H", "h"].each do |chr|
-      assert_equal "H", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'I' letters" do
-    ["I", "i", "Ì", "Í", "Î", "Ï", "ì", "í", "î", "ï"].each do |chr|
-      assert_equal "I", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'J' letters" do
-    ["J", "j"].each do |chr|
-      assert_equal "J", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'K' letters" do
-    ["K", "k"].each do |chr|
-      assert_equal "K", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'L' letters" do
-    ["L", "l"].each do |chr|
-      assert_equal "L", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'M' letters" do
-    ["M", "m"].each do |chr|
-      assert_equal "M", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'N' letters" do
-    ["N", "n", "Ñ", "ñ"].each do |chr|
-      assert_equal "N", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'O' letters" do
-    ["O", "o", "Ò", "Ó", "Ô", "Õ", "ò", "ó", "ô", "õ"].each do |chr|
-      assert_equal "O", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'P' letters" do
-    ["P", "p"].each do |chr|
-      assert_equal "P", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'Q' letters" do
-    ["Q", "q"].each do |chr|
-      assert_equal "Q", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'R' letters" do
-    ["R", "r"].each do |chr|
-      assert_equal "R", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'S' letters" do
-    ["S", "s"].each do |chr|
-      assert_equal "S", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'T' letters" do
-    ["T", "t"].each do |chr|
-      assert_equal "T", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'U' letters" do
-    ["U", "u", "Ù", "Ú", "Û", "ù", "ú", "û"].each do |chr|
-      assert_equal "U", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'V' letters" do
-    ["V", "v"].each do |chr|
-      assert_equal "V", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'W' letters" do
-    ["W", "w"].each do |chr|
-      assert_equal "W", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'X' letters" do
-    ["X", "x"].each do |chr|
-      assert_equal "X", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'Y' letters" do
-    ["Y", "y", "Ü", "Ý", "ü", "ý"].each do |chr|
-      assert_equal "Y", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'Z' letters" do
-    ["Z", "z"].each do |chr|
-      assert_equal "Z", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles '[' letters" do
-    ["[", "Å", "å"].each do |chr|
-      assert_equal "[", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles '\\' letters" do
-    ["\\", "Ä", "Æ", "ä", "æ"].each do |chr|
-      assert_equal "\\", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles ']' letters" do
-    ["]", "Ö", "ö"].each do |chr|
-      assert_equal "]", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'Ø' letters" do
-    ["Ø", "ø"].each do |chr|
-      assert_equal "Ø", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci handles 'Þ' letters" do
-    ["Þ", "þ"].each do |chr|
-      assert_equal "Þ", decollate(chr, :mysql, "latin1_swedish_ci")
-    end
-  end
-
-  test "mysql's latin1_swedish_ci ignores trailing spaces" do
-    assert_equal "FOO", decollate("foo ", :mysql, "latin1_swedish_ci")
-  end
-
-  test "unknown collation" do
-    assert_equal "fOo", decollate("fOo", :foo, :bar)
-  end
-end

data/test/unit/test_function.rb

@@ -1,233 +0,0 @@
-require 'helper'
-
-class UnitTests::TestFunction < Test::Unit::TestCase
-
-  def setup
-    super
-    @_functions = Linkage::Function.instance_variable_get("@functions")
-  end
-
-  def teardown
-    Linkage::Function.instance_variable_set("@functions", @_functions)
-    super
-  end
-
-  test "subclass of data" do
-    assert_equal Linkage::Data, Linkage::Function.superclass
-  end
-
-  test "function_name returns nil in base class" do
-    assert_raises(NotImplementedError) { Linkage::Function.function_name }
-  end
-
-  test "ruby_type raises not implemented error in base class" do
-    klass = Class.new(Linkage::Function)
-    klass.send(:define_singleton_method, :function_name) { "foo" }
-    dataset = stub('dataset')
-    f = klass.new(:dataset => dataset)
-    assert_raises(NotImplementedError) { f.ruby_type }
-  end
-
-  test "registering subclass requires non-nil function_name" do
-    klass = Class.new(Linkage::Function)
-    assert_raises(ArgumentError) { Linkage::Function.register(klass) }
-  end
-
-  test "registering subclass requires ruby_type" do
-    klass = new_function('foo')
-    assert_raises(ArgumentError) { Linkage::Function.register(klass) }
-  end
-
-  test "function with no arguments" do
-    klass = new_function('foo', {:type => String})
-    f = klass.new(:dataset => stub('dataset'))
-    assert_equal :foo, f.name
-    assert_equal :foo.sql_function, f.to_expr
-    assert f.static?
-  end
-
-  test "function with static value" do
-    klass = new_function('foo', {:type => String})
-    f = klass.new(123, :dataset => stub('dataset'))
-    assert_equal :foo.sql_function(123), f.to_expr
-    assert_equal :foo_123, f.name
-    assert f.static?
-  end
-
-  test "function with field" do
-    klass = new_function('foo', {:type => String})
-
-    dataset = stub('dataset')
-    field = stub_field('field', {
-      :name => :bar, :to_expr => :bar,
-      :ruby_type => {:type => String}, :dataset => dataset
-    })
-    f = klass.new(field)
-    assert_equal :foo_bar, f.name
-    assert_equal :foo.sql_function(:bar), f.to_expr
-    assert_equal dataset, f.dataset
-    assert !f.static?
-  end
-
-  test "creating function with conflicting datasets raises exception" do
-    klass = new_function('foo', {:type => String}, [[String], [String]])
-
-    dataset_1 = stub('dataset')
-    field_1 = stub_field('field 1', {
-      :name => :foo, :to_expr => :foo,
-      :ruby_type => {:type => String}, :dataset => dataset_1
-    })
-    dataset_2 = stub('dataset')
-    field_2 = stub_field('field 2', {
-      :name => :bar, :to_expr => :bar,
-      :ruby_type => {:type => String}, :dataset => dataset_2
-    })
-
-    assert_raises(ArgumentError) { klass.new(field_1, field_2) }
-  end
-
-  test "getting dataset for a static function without dataset raises exception" do
-    klass = new_function('foo', {:type => String})
-    func = klass.new
-    assert_raises(RuntimeError) { func.dataset }
-  end
-
-  test "function with dynamic function" do
-    klass_1 = new_function('foo', {:type => String})
-    klass_2 = new_function('bar', {:type => String})
-
-    field = stub_field('field', :name => :baz, :to_expr => :baz, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    func_1 = klass_1.new(field)
-    assert_equal :foo_baz, func_1.name
-    assert !func_1.static?
-
-    func_2 = klass_2.new(func_1)
-    assert_equal :bar_foo_baz, func_2.name
-    assert !func_2.static?
-    assert_equal :bar.sql_function(:foo.sql_function(:baz)), func_2.to_expr
-  end
-
-  test "function with static function" do
-    klass_1 = new_function('foo', {:type => String})
-    klass_2 = new_function('bar', {:type => String})
-
-    func_1 = klass_1.new(123, :dataset => stub('dataset'))
-    assert_equal :foo_123, func_1.name
-    assert func_1.static?
-
-    func_2 = klass_2.new(func_1)
-    assert_equal :bar_foo_123, func_2.name
-    assert_equal :bar.sql_function(:foo.sql_function(123)), func_2.to_expr
-    assert func_2.static?
-  end
-
-  test "function with mixed function arguments" do
-    klass_1 = new_function('foo', {:type => String})
-    klass_2 = new_function('bar', {:type => String})
-    klass_3 = new_function('baz', {:type => String})
-
-    dataset = stub('dataset')
-    func_1 = klass_1.new(123, :dataset => dataset)
-    assert_equal :foo_123, func_1.name
-    assert func_1.static?
-
-    field = stub_field('field', :name => :quux, :to_expr => :quux, :ruby_type => {:type => String}, :dataset => dataset)
-    func_2 = klass_2.new(field)
-    assert_equal :bar_quux, func_2.name
-    assert !func_2.static?
-
-    func_3 = klass_3.new(func_2, func_1)
-    assert_equal :baz_bar_quux_foo_123, func_3.name
-    assert !func_3.static?
-    assert_equal :baz.sql_function(:bar.sql_function(:quux), :foo.sql_function(123)), func_3.to_expr
-  end
-
-  test "function with multiple fields" do
-    klass = new_function('foo', {:type => String})
-    dataset = stub('dataset')
-    field_1 = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {:type => String}, :dataset => dataset)
-    field_2 = stub_field('field', :name => :baz, :to_expr => :baz, :ruby_type => {:type => String}, :dataset => dataset)
-    func = klass.new(field_1, field_2)
-    assert_equal :foo_bar_baz, func.name
-    assert_equal :foo.sql_function(:bar, :baz), func.to_expr
-    assert !func.static?
-  end
-
-  test "function with multiple mixed arguments" do
-    klass = new_function('foo', {:type => String})
-    field = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {:type => String}, :dataset => stub('dataset'))
-    f = klass.new(field, 123, 'abc')
-    assert_equal :foo_bar_123_abc, f.name
-    assert_equal :foo.sql_function(:bar, 123, 'abc'), f.to_expr
-  end
-
-  test "fetching registered function" do
-    klass = new_function('foo', {:type => String})
-    Linkage::Function.register(klass)
-    assert_equal klass, Linkage::Function['foo']
-  end
-
-  test "valid parameters" do
-    klass = new_function('foo', {:type => String}, [[String]])
-    dataset = stub('dataset')
-    assert_equal :foo.sql_function("foo"), klass.new("foo", :dataset => dataset).to_expr
-    field = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {:type => String})
-    assert_equal :foo.sql_function(:bar), klass.new(field, :dataset => dataset).to_expr
-    assert_equal :foo.sql_function(:foo.sql_function("hey")), klass.new(klass.new("hey", :dataset => dataset)).to_expr
-  end
-
-  test "invalid parameters" do
-    func = new_function('foo', {:type => String}, [[String]])
-    assert_raises(TypeError) do
-      func.new(123)
-    end
-    field = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {:type => Integer})
-    assert_raises(TypeError) do
-      func.new(field)
-    end
-    func2 = new_function('bar', {:type => Integer})
-    dataset = stub('dataset')
-    assert_raises(TypeError) do
-      func.new(func2.new(:dataset => dataset))
-    end
-    assert_raises(ArgumentError) do
-      func.new("123", "456")
-    end
-    assert_raises(ArgumentError) do
-      func.new
-    end
-  end
-
-  test "two functions with the same name and arguments and datasets are equal" do
-    klass = new_function('foo', {:type => String}, [[String]])
-    dataset = stub('dataset')
-    field = stub_field('field', :dataset => dataset, :ruby_type => {:type => String})
-
-    func_1 = klass.new(field)
-    func_2 = klass.new(field)
-    assert func_1 == func_2
-  end
-
-  test "#== with two static functions" do
-    klass = new_function('foo', {:type => String}, [[String]])
-    dataset = stub('dataset')
-    func_1 = klass.new('foo', :dataset => dataset)
-    func_2 = klass.new('foo', :dataset => dataset)
-    assert func_1 == func_2
-  end
-
-  test "collation returns nil by default" do
-    klass = new_function('foo', {:type => String}, [[String]])
-    dataset = stub('dataset')
-    func = klass.new('foo', :dataset => dataset)
-    assert_nil func.collation
-  end
-
-  test "special :any parameter" do
-    klass = new_function('foo', {:type => String}, [[:any]])
-    dataset = stub('dataset')
-    assert_nothing_raised do
-      klass.new('foo', :dataset => dataset)
-    end
-  end
-end

data/test/unit/test_group.rb

@@ -1,38 +0,0 @@
-require 'helper'
-
-class UnitTests::TestGroup < Test::Unit::TestCase
-  test "initialize" do
-    g = Linkage::Group.new({:test => 'test'}, {:count => 1, :id => 456})
-    assert_equal({:test => 'test'}, g.values)
-    assert_equal 1, g.count
-    assert_equal 456, g.id
-  end
-
-  test "decollate strings" do
-    test_ruby_type = { :type => String, :opts => { :collate => "latin1_swedish_ci" } }
-    group = Linkage::Group.new({:test => 'TeSt '}, {
-      :count => 1, :id => 456, :ruby_types => { :test => test_ruby_type },
-      :database_type => :mysql
-    })
-    assert_equal({:test => "TEST"}, group.decollated_values)
-  end
-
-  test "don't decollate non-strings or strings without collation information" do
-    ruby_types = {
-      :foo => {
-        :type => String, :opts => { :collate => "latin1_swedish_ci" }
-      },
-      :bar => {
-        :type => Fixnum
-      },
-      :baz => {
-        :type => String
-      }
-    }
-    group = Linkage::Group.new({:foo => 'foO', :bar => 123, :baz => "foO"}, {
-      :count => 1, :id => 456, :ruby_types => ruby_types,
-      :database_type => :mysql
-    })
-    assert_equal({:foo => "FOO", :bar => 123, :baz => "foO"}, group.decollated_values)
-  end
-end

data/test/unit/test_meta_object.rb

@@ -1,208 +0,0 @@
-require 'helper'
-
-class UnitTests::TestMetaObject < Test::Unit::TestCase
-  test "initialize with static string" do
-    meta_object = Linkage::MetaObject.new("foo")
-    assert meta_object.static?
-    assert_equal "foo", meta_object.object
-    assert_nil meta_object.side
-  end
-
-  test "initialize with static function" do
-    function = stub_function("foo", :static? => true)
-    meta_object = Linkage::MetaObject.new(function)
-    assert meta_object.static?
-    assert_equal function, meta_object.object
-    assert_nil meta_object.side
-  end
-
-  test "initialize with field" do
-    field = stub_field("foo")
-    meta_object = Linkage::MetaObject.new(field, :lhs)
-    assert !meta_object.static?
-    assert_equal field, meta_object.object
-    assert_equal :lhs, meta_object.side
-  end
-
-  test "getting side for dynamic object without setting it raises error" do
-    meta_object = Linkage::MetaObject.new(stub_field('foo'))
-    assert_raises(RuntimeError) { meta_object.side }
-  end
-
-  test "getting dataset calls #dataset on object" do
-    field = stub_field('foo')
-    meta_object = Linkage::MetaObject.new(field)
-
-    dataset = stub('dataset')
-    field.expects(:dataset).returns(dataset)
-    assert_equal dataset, meta_object.dataset
-  end
-
-  test "setting dataset sets object's dataset" do
-    func = stub_function('foo')
-    meta_object = Linkage::MetaObject.new(func)
-
-    dataset = stub('dataset')
-    func.expects(:dataset=).with(dataset)
-    meta_object.dataset = dataset
-  end
-
-  test "setting dataset on non-data object raises exception" do
-    meta_object = Linkage::MetaObject.new(123)
-    dataset = stub('dataset')
-    assert_raises(RuntimeError) { meta_object.dataset = dataset }
-  end
-
-  test "objects_equal? compares only objects, not sides" do
-    field = stub_field("foo")
-    object_1 = Linkage::MetaObject.new(field, :lhs)
-    object_2 = Linkage::MetaObject.new(field, :rhs)
-    object_3 = Linkage::MetaObject.new(123)
-    assert object_1.objects_equal?(object_2)
-    assert !object_1.objects_equal?("foo")
-    assert !object_2.objects_equal?(object_3)
-  end
-
-  test "dataset reader for field" do
-    dataset = stub('dataset')
-    field = stub_field("foo", :dataset => dataset)
-    object = Linkage::MetaObject.new(field, :lhs)
-
-    assert_equal dataset, object.dataset
-  end
-
-  test "dataset reader for function" do
-    dataset = stub('dataset')
-    function = stub_function("foo", :dataset => dataset)
-    object = Linkage::MetaObject.new(function, :lhs)
-
-    assert_equal dataset, object.dataset
-  end
-
-  test "datasets_equal?" do
-    dataset_1 = stub('dataset 1')
-    field_1 = stub_field('field 1', :dataset => dataset_1)
-    object_1 = Linkage::MetaObject.new(field_1, :lhs)
-
-    dataset_2 = stub('dataset 2')
-    field_2 = stub_field('field 2', :dataset => dataset_2)
-    object_2 = Linkage::MetaObject.new(field_2, :rhs)
-
-    field_3 = stub_field('field 3', :dataset => dataset_2)
-    object_3 = Linkage::MetaObject.new(field_3, :rhs)
-
-    object_4 = Linkage::MetaObject.new(123)
-
-    assert object_1.datasets_equal?(object_1)
-    assert object_2.datasets_equal?(object_3)
-    assert !object_1.datasets_equal?(object_2)
-    assert !object_1.datasets_equal?("foo")
-    assert !object_1.datasets_equal?(object_4)
-  end
-
-  test "to_expr for non-data object returns object" do
-    object = Linkage::MetaObject.new(123)
-    assert_equal 123, object.to_expr
-  end
-
-  test "to_expr for data object returns object.to_expr" do
-    field = stub_field('field')
-    object = Linkage::MetaObject.new(field, :lhs)
-
-    field.expects(:to_expr).returns(:foo)
-    assert_equal :foo, object.to_expr
-  end
-
-  test "to_identifier for non-data object returns object" do
-    object = Linkage::MetaObject.new(123)
-    assert_equal 123, object.to_identifier
-  end
-
-  test "to_identifer for data object returns identifier object" do
-    field = stub_field('field')
-    object = Linkage::MetaObject.new(field, :lhs)
-
-    field.expects(:to_expr).returns(:foo)
-    assert_equal(Sequel::SQL::Identifier.new(:foo), object.to_identifier)
-  end
-
-  test "merge with data object" do
-    field_1 = stub_field('field 1')
-    object_1 = Linkage::MetaObject.new(field_1, :lhs)
-    field_2 = stub_field('field 2')
-    object_2 = Linkage::MetaObject.new(field_2, :rhs)
-
-    merged_field = stub('merged field')
-    field_1.expects(:merge).with(field_2).returns(merged_field)
-    assert_equal merged_field, object_1.merge(object_2)
-  end
-
-  test "merge with non-data object raises exception" do
-    field_1 = stub_field('field 1')
-    object_1 = Linkage::MetaObject.new(field_1, :lhs)
-    object_2 = Linkage::MetaObject.new(123)
-    assert_raises(ArgumentError) { object_1.merge(object_2) }
-    assert_raises(ArgumentError) { object_2.merge(object_1) }
-  end
-
-  test "ruby_type calls Field#ruby_type" do
-    field = stub_field('field')
-    object = Linkage::MetaObject.new(field, :lhs)
-    field.expects(:ruby_type).returns(:type => String)
-    assert_equal({:type => String}, object.ruby_type)
-  end
-
-  test "ruby_type calls Function#ruby_type" do
-    function = stub_function("foo")
-    object = Linkage::MetaObject.new(function, :lhs)
-    function.expects(:ruby_type).returns(:type => String)
-    assert_equal({:type => String}, object.ruby_type)
-  end
-
-  test "ruby_type returns object class for non-data object" do
-    object = Linkage::MetaObject.new(123)
-    assert_equal({:type => Fixnum}, object.ruby_type)
-  end
-
-  test "database_type" do
-    dataset = mock('dataset')
-    field = stub_field('field', :dataset => dataset)
-    object = Linkage::MetaObject.new(field, :lhs)
-    dataset.expects(:database_type).returns(:mysql)
-    assert_equal :mysql, object.database_type
-  end
-
-  test "#collation returns Data#collation" do
-    dataset = mock('dataset')
-    field = stub_field('field', :dataset => dataset, :collation => 'foo')
-    object = Linkage::MetaObject.new(field, :lhs)
-    assert_equal 'foo', object.collation
-  end
-
-  test "#collation returns nil when underlying object is not a Data object" do
-    object = Linkage::MetaObject.new(123, :lhs)
-    assert_nil object.collation
-  end
-
-  test "#name for data object" do
-    field = stub_field('foo', :name => :foo)
-    object = Linkage::MetaObject.new(field, :lhs)
-    assert_equal :foo, object.name
-  end
-
-  test "#name for non-data object returns nil" do
-    object = Linkage::MetaObject.new(123)
-    assert_nil object.name
-  end
-
-  test "#raw? returns true for non-data object" do
-    object = Linkage::MetaObject.new(123)
-    assert object.raw?
-  end
-
-  test "#raw? returns false for data object" do
-    field = stub_field('foo', :name => :foo)
-    object = Linkage::MetaObject.new(field, :lhs)
-    assert !object.raw?
-  end
-end