linkage 0.0.6 → 0.0.8

data/test/unit/test_decollation.rb

@@ -0,0 +1,201 @@
+# 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_field.rb

@@ -6,45 +6,69 @@ class UnitTests::TestField < Test::Unit::TestCase
   end
 
   test "initialize with schema info" do
+    dataset = stub('dataset')
     schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
-    field = Linkage::Field.new(:id, schema)
+    field = Linkage::Field.new(dataset, :id, schema)
     assert_equal :id, field.name
     assert_equal schema, field.schema
-  end
-
-  test "initialize with ruby type" do
-    info = {:type => Integer}
-    field = Linkage::Field.new(:id, nil, info)
-    assert_equal :id, field.name
-    assert_equal info, field.ruby_type
+    assert_equal dataset, field.dataset
   end
 
   test "static? is always false" do
+    dataset = stub('dataset')
     schema = {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil}
-    field = Linkage::Field.new(:id, schema)
+    field = Linkage::Field.new(dataset, :id, schema)
     assert !field.static?
   end
 
   test "ruby_type for integer" do
-    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    dataset = stub('dataset')
+    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert_equal({:type => Integer}, field.ruby_type)
   end
 
   test "primary_key? returns true if primary key" do
-    field_1 = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    dataset = stub('dataset')
+    field_1 = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert field_1.primary_key?
 
-    field_2 = Linkage::Field.new(:foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    field_2 = Linkage::Field.new(dataset, :foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert !field_2.primary_key?
   end
 
   test "to_expr returns name" do
-    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    dataset = stub('dataset')
+    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert_equal :id, field.to_expr
   end
 
   test "to_expr ignores adapter argument" do
-    field = Linkage::Field.new(:id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
+    dataset = stub('dataset')
+    field = Linkage::Field.new(dataset, :id, {:allow_null=>true, :default=>nil, :primary_key=>true, :db_type=>"integer", :type=>:integer, :ruby_default=>nil})
     assert_equal :id, field.to_expr(:foo)
   end
+
+  test "collation" do
+    dataset = stub('dataset')
+    field = Linkage::Field.new(dataset, :foo, {:allow_null=>true, :default=>nil, :primary_key=>false, :db_type=>"varchar(255)", :type=>:string, :collation=>"latin1_general_cs", :ruby_default=>nil})
+    assert_equal "latin1_general_cs", field.collation
+    assert_equal "latin1_general_cs", field.ruby_type[:opts][:collate]
+  end
+
+  test "initialize MergeField with ruby type" do
+    info = {:type => Integer}
+    field = Linkage::MergeField.new(:id, info)
+    assert_equal :id, field.name
+    assert_equal info, field.ruby_type
+    assert_nil field.schema
+    assert_nil field.dataset
+  end
+
+  test "MergeField#database_type accessor" do
+    field_1 = Linkage::MergeField.new(:id, {:type => Integer})
+    assert_nil field_1.database_type
+
+    field_2 = Linkage::MergeField.new(:id, {:type => Integer}, :mysql)
+    assert_equal :mysql, field_2.database_type
+  end
 end

data/test/unit/test_field_set.rb

@@ -15,14 +15,16 @@ class UnitTests::TestFieldSet < Test::Unit::TestCase
   end
 
   test "creates fields on initialization" do
+    dataset = mock('dataset', :schema => @schema)
+
     field_1 = stub('id field')
     field_2 = stub('first_name field')
     field_3 = stub('last_name field')
-    Linkage::Field.expects(:new).with(:id, @schema[:id]).returns(field_1)
-    Linkage::Field.expects(:new).with(:first_name, @schema[:first_name]).returns(field_2)
-    Linkage::Field.expects(:new).with(:last_name, @schema[:last_name]).returns(field_3)
+    Linkage::Field.expects(:new).with(dataset, :id, @schema[:id]).returns(field_1)
+    Linkage::Field.expects(:new).with(dataset, :first_name, @schema[:first_name]).returns(field_2)
+    Linkage::Field.expects(:new).with(dataset, :last_name, @schema[:last_name]).returns(field_3)
 
-    fs = Linkage::FieldSet.new(@schema)
+    fs = Linkage::FieldSet.new(dataset)
     assert_equal field_1, fs.primary_key
     assert_equal field_1, fs[:id]
     assert_equal field_2, fs[:first_name]
@@ -30,14 +32,16 @@ class UnitTests::TestFieldSet < Test::Unit::TestCase
   end
 
   test "case-insensitive names" do
+    dataset = stub('dataset', :schema => @schema)
+
     field_1 = stub('id field')
     field_2 = stub('first_name field')
     field_3 = stub('last_name field')
-    Linkage::Field.stubs(:new).with(:id, @schema[:id]).returns(field_1)
-    Linkage::Field.stubs(:new).with(:first_name, @schema[:first_name]).returns(field_2)
-    Linkage::Field.stubs(:new).with(:last_name, @schema[:last_name]).returns(field_3)
+    Linkage::Field.stubs(:new).with(dataset, :id, @schema[:id]).returns(field_1)
+    Linkage::Field.stubs(:new).with(dataset, :first_name, @schema[:first_name]).returns(field_2)
+    Linkage::Field.stubs(:new).with(dataset, :last_name, @schema[:last_name]).returns(field_3)
 
-    fs = Linkage::FieldSet.new(@schema)
+    fs = Linkage::FieldSet.new(dataset)
     assert_equal field_1, fs.primary_key
     assert_equal field_1, fs[:Id]
     assert_equal field_2, fs[:fIrst_name]

data/test/unit/test_function.rb

@@ -23,7 +23,8 @@ class UnitTests::TestFunction < Test::Unit::TestCase
   test "ruby_type raises not implemented error in base class" do
     klass = Class.new(Linkage::Function)
     klass.send(:define_singleton_method, :function_name) { "foo" }
-    f = klass.new
+    dataset = stub('dataset')
+    f = klass.new(:dataset => dataset)
     assert_raises(NotImplementedError) { f.ruby_type }
   end
 
@@ -39,7 +40,7 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with no arguments" do
     klass = new_function('foo', {:type => String})
-    f = klass.new
+    f = klass.new(:dataset => stub('dataset'))
     assert_equal :foo, f.name
     assert_equal :foo.sql_function, f.to_expr
     assert f.static?
@@ -47,7 +48,7 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with static value" do
     klass = new_function('foo', {:type => String})
-    f = klass.new(123)
+    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?
@@ -55,18 +56,47 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with field" do
     klass = new_function('foo', {:type => String})
-    field = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {: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})
+    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?
@@ -81,7 +111,7 @@ class UnitTests::TestFunction < Test::Unit::TestCase
     klass_1 = new_function('foo', {:type => String})
     klass_2 = new_function('bar', {:type => String})
 
-    func_1 = klass_1.new(123)
+    func_1 = klass_1.new(123, :dataset => stub('dataset'))
     assert_equal :foo_123, func_1.name
     assert func_1.static?
 
@@ -96,11 +126,12 @@ class UnitTests::TestFunction < Test::Unit::TestCase
     klass_2 = new_function('bar', {:type => String})
     klass_3 = new_function('baz', {:type => String})
 
-    func_1 = klass_1.new(123)
+    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})
+    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?
@@ -113,8 +144,9 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   test "function with multiple fields" do
     klass = new_function('foo', {:type => String})
-    field_1 = stub_field('field', :name => :bar, :to_expr => :bar, :ruby_type => {:type => String})
-    field_2 = stub_field('field', :name => :baz, :to_expr => :baz, :ruby_type => {: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
@@ -123,7 +155,7 @@ class UnitTests::TestFunction < Test::Unit::TestCase
 
   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})
+    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
@@ -136,11 +168,12 @@ class UnitTests::TestFunction < Test::Unit::TestCase
   end
 
   test "valid parameters" do
-    func = new_function('foo', {:type => String}, [[String]])
-    assert_equal :foo.sql_function("foo"), func.new("foo").to_expr
+    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), func.new(field).to_expr
-    assert_equal :foo.sql_function(:foo.sql_function("hey")), func.new(func.new("hey")).to_expr
+    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
@@ -153,8 +186,9 @@ class UnitTests::TestFunction < Test::Unit::TestCase
       func.new(field)
     end
     func2 = new_function('bar', {:type => Integer})
+    dataset = stub('dataset')
     assert_raises(TypeError) do
-      func.new(func2.new)
+      func.new(func2.new(:dataset => dataset))
     end
     assert_raises(ArgumentError) do
       func.new("123", "456")
@@ -163,4 +197,37 @@ class UnitTests::TestFunction < Test::Unit::TestCase
       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

@@ -7,4 +7,32 @@ class UnitTests::TestGroup < Test::Unit::TestCase
     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_import_buffer.rb

@@ -2,50 +2,36 @@ require 'helper'
 
 class UnitTests::TestImportBuffer < Test::Unit::TestCase
   test "basic usage" do
-    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud])
+    database = stub('database')
+    dataset = stub('dataset', :db => database)
+
+    buf = Linkage::ImportBuffer.new(dataset, [:qux, :thud])
     buf.add([123, 456])
     buf.add(['test', 'junk'])
 
-    database = mock('database')
-    Sequel.expects(:connect).with('foo:/bar/db', {}).yields(database)
-    dataset = mock('dataset')
-    database.expects(:[]).with(:baz_table).returns(dataset)
+    database.expects(:synchronize).yields
     dataset.expects(:import).with([:qux, :thud], [[123, 456], ['test', 'junk']])
     buf.flush
   end
 
   test "flush performs a no-op when buffer is empty" do
-    Sequel.expects(:connect).never
-    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud])
+    database = stub('database')
+    dataset = stub('dataset', :db => database)
+    dataset.expects(:import).never
+    buf = Linkage::ImportBuffer.new(dataset, [:qux, :thud])
     buf.flush
   end
 
   test "auto-flush" do
-    uri = 'foo:/bar/db'
-    table = 'baz_table'
+    database = stub('database')
+    dataset = stub('dataset', :db => database)
     headers = [:qux, :thud]
     limit = 3
-    buf = Linkage::ImportBuffer.new(uri, table, headers, {}, limit)
+    buf = Linkage::ImportBuffer.new(dataset, headers, limit)
     2.times { |i| buf.add([123, 456]) }
 
-    database = mock('database')
-    Sequel.expects(:connect).with('foo:/bar/db', {}).yields(database)
-    dataset = mock('dataset')
-    database.expects(:[]).with(:baz_table).returns(dataset)
+    database.expects(:synchronize).yields
     dataset.expects(:import).with([:qux, :thud], [[123, 456], [123, 456], ['test', 'junk']])
     buf.add(['test', 'junk'])
   end
-
-  test "accepts Sequel.connect options" do
-    buf = Linkage::ImportBuffer.new('foo:/bar/db', 'baz_table', [:qux, :thud], :foo => 123)
-    buf.add([123, 456])
-    buf.add(['test', 'junk'])
-
-    database = mock('database')
-    Sequel.expects(:connect).with('foo:/bar/db', :foo => 123).yields(database)
-    dataset = mock('dataset')
-    database.expects(:[]).with(:baz_table).returns(dataset)
-    dataset.expects(:import).with([:qux, :thud], [[123, 456], ['test', 'junk']])
-    buf.flush
-  end
 end