lhm-shopify 3.5.5 → 4.1.0

data/spec/integration/sql_retry/retry_with_proxysql_spec.rb

@@ -1,5 +1,4 @@
 require 'minitest/autorun'
-require 'mysql2'
 require 'lhm'
 require 'toxiproxy'
 
@@ -50,7 +49,7 @@ describe Lhm::SqlRetry, "ProxiSQL tests for LHM retry" do
       end
     end
 
-    assert_equal @connection.execute("Select * from #{DBConnectionHelper.test_table_name} WHERE id=2000").to_a.first.first, 2000
+    assert_equal 2000, @connection.select_one("SELECT * FROM #{DBConnectionHelper.test_table_name} WHERE id=2000")["id"]
 
     logs = @logger.string.split("\n")
 

data/spec/integration/table_spec.rb

@@ -23,7 +23,7 @@ describe Lhm::Table do
       end
 
       it 'should parse columns' do
-        value(@table.columns['id'][:type]).must_match(/(bigint|int)\(\d+\)/)
+        value(@table.columns['id'][:type]).must_match(/(bigint|int)(\(\d+\))?/)
       end
 
       it 'should return true for method that should be renamed' do

data/spec/integration/toxiproxy_helper.rb

@@ -7,7 +7,7 @@ module ToxiproxyHelper
     def included(base)
       Toxiproxy.reset
 
-      # listen on localhost, but toxiproxy is in a container itself, thus the upstream uses the Docker-Compose DNS
+      # listen on localhost, but toxiproxy is in a container itself, thus the upstream uses the Podman-Compose DNS
       Toxiproxy.populate(
         [
           {

data/spec/test_helper.rb

@@ -14,6 +14,7 @@ require 'after_do'
 require 'byebug'
 require 'pathname'
 require 'lhm'
+require 'active_record'
 
 $project = Pathname.new(File.dirname(__FILE__) + '/..').cleanpath
 $spec = $project.join('spec')
@@ -21,8 +22,31 @@ $fixtures = $spec.join('fixtures')
 
 $db_name = 'test'
 
-require 'active_record'
-require 'mysql2'
+Database = Struct.new(:adapter, :client, :error_class, :timeout_error) do
+  def query(connection, sql)
+    results = connection.query(sql)
+    results = results.each_hash if adapter == "trilogy"
+    results
+  end
+end
+
+DATABASE =
+  case ENV['DATABASE_ADAPTER']
+  when 'trilogy'
+    require 'trilogy'
+
+    if ActiveRecord.version < ::Gem::Version.new('7.1.0')
+      require 'activerecord-trilogy-adapter'
+      require 'trilogy_adapter/connection'
+
+      ActiveRecord::Base.public_send :extend, TrilogyAdapter::Connection
+    end
+
+    Database.new('trilogy', Trilogy, Trilogy::BaseError, Trilogy::TimeoutError)
+  else
+    require 'mysql2'
+    Database.new('mysql2', Mysql2::Client, Mysql2::Error, Mysql2::Error::TimeoutError)
+  end
 
 logger = Logger.new STDOUT
 logger.level = Logger::WARN
@@ -53,7 +77,7 @@ end
 
 def init_test_db
   db_config = YAML.load_file(File.expand_path(File.dirname(__FILE__)) + '/integration/database.yml')
-  conn = Mysql2::Client.new(
+  conn = DATABASE.client.new(
     :host => '127.0.0.1',
     :username => db_config['master']['user'],
     :password => db_config['master']['password'],

data/spec/unit/atomic_switcher_spec.rb

@@ -21,8 +21,8 @@ describe Lhm::AtomicSwitcher do
   describe 'atomic switch' do
     it 'should perform a single atomic rename' do
       value(@switcher.atomic_switch).must_equal(
-        "rename table `origin` to `#{ @migration.archive_name }`, " \
-        '`destination` to `origin`'
+        "RENAME TABLE `origin` TO `#{ @migration.archive_name }`, " \
+        '`destination` TO `origin`'
       )
     end
   end

data/spec/unit/chunker_spec.rb

@@ -20,7 +20,7 @@ describe Lhm::Chunker do
     @destination = Lhm::Table.new('bar')
     @migration = Lhm::Migration.new(@origin, @destination)
     @connection = mock()
-    @connection.stubs(:execute).returns([["dummy"]])
+    @connection.stubs(:select_value).returns("dummy")
     # This is a poor man's stub
     @throttler = Object.new
     def @throttler.run
@@ -42,11 +42,11 @@ describe Lhm::Chunker do
         5
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 4/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(7)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 8 order by id limit 1 offset 4/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(21)
-      @connection.expects(:update).with(regexp_matches(/between 1 and 7/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 8 and 10/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:execute).twice.with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 4/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(7)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 8 order by id limit 1 offset 4/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(21)
+      @connection.expects(:update).with(regexp_matches(/between 1 and 7/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 8 and 10/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:select_all).twice.with(regexp_matches(/show warnings/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
 
       @chunker.run
     end
@@ -57,17 +57,17 @@ describe Lhm::Chunker do
         2
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 3 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(4)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 5 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(6)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 7 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(8)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 9 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(10)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 3 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(4)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 5 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(6)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 7 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(8)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 9 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(10)
 
-      @connection.expects(:update).with(regexp_matches(/between 1 and 2/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 3 and 4/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 5 and 6/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 7 and 8/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 9 and 10/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 1 and 2/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 3 and 4/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 5 and 6/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 7 and 8/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 9 and 10/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
 
       @chunker.run
     end
@@ -84,17 +84,17 @@ describe Lhm::Chunker do
         end
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 3 order by id limit 1 offset 2/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(5)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 6 order by id limit 1 offset 2/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(8)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 9 order by id limit 1 offset 2/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 3 order by id limit 1 offset 2/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(5)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 6 order by id limit 1 offset 2/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(8)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 9 order by id limit 1 offset 2/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
 
-      @connection.expects(:update).with(regexp_matches(/between 1 and 2/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 3 and 5/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 6 and 8/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 9 and 10/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 1 and 2/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 3 and 5/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 6 and 8/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 9 and 10/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
 
-      @connection.expects(:execute).twice.with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+      @connection.expects(:select_all).twice.with(regexp_matches(/show warnings/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
 
       @chunker.run
     end
@@ -104,8 +104,8 @@ describe Lhm::Chunker do
                                                            :start     => 1,
                                                            :limit     => 1)
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 0/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
-      @connection.expects(:update).with(regexp_matches(/between 1 and 1/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 0/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
+      @connection.expects(:update).with(regexp_matches(/between 1 and 1/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
 
       @chunker.run
     end
@@ -118,17 +118,17 @@ describe Lhm::Chunker do
         2
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 2 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(3)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 4 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(5)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 6 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(7)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 8 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(9)
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 10 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 2 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(3)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 4 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(5)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 6 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(7)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 8 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(9)
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 10 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(nil)
 
-      @connection.expects(:update).with(regexp_matches(/between 2 and 3/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 4 and 5/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 6 and 7/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 8 and 9/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
-      @connection.expects(:update).with(regexp_matches(/between 10 and 10/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:update).with(regexp_matches(/between 2 and 3/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 4 and 5/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 6 and 7/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 8 and 9/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(2)
+      @connection.expects(:update).with(regexp_matches(/between 10 and 10/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
 
       @chunker.run
     end
@@ -142,9 +142,9 @@ describe Lhm::Chunker do
         2
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
-      @connection.expects(:update).with(regexp_matches(/where \(foo.created_at > '2013-07-10' or foo.baz = 'quux'\) and `foo`/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
-      @connection.expects(:execute).with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
+      @connection.expects(:update).with(regexp_matches(/where \(foo.created_at > '2013-07-10' or foo.baz = 'quux'\) and `foo`/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:select_all).with(regexp_matches(/show warnings/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
 
       def @migration.conditions
         "where foo.created_at > '2013-07-10' or foo.baz = 'quux'"
@@ -162,9 +162,9 @@ describe Lhm::Chunker do
         2
       end
 
-      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/),EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
-      @connection.expects(:update).with(regexp_matches(/inner join bar on foo.id = bar.foo_id and/),EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
-      @connection.expects(:execute).with(regexp_matches(/show warnings/),EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
+      @connection.expects(:select_value).with(regexp_matches(/where id >= 1 order by id limit 1 offset 1/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns(2)
+      @connection.expects(:update).with(regexp_matches(/inner join bar on foo.id = bar.foo_id and/i), EXPECTED_RETRY_FLAGS_CHUNK_INSERT).returns(1)
+      @connection.expects(:select_all).with(regexp_matches(/show warnings/i), EXPECTED_RETRY_FLAGS_CHUNKER).returns([])
 
       def @migration.conditions
         'inner join bar on foo.id = bar.foo_id'

data/spec/unit/connection_spec.rb

@@ -93,7 +93,7 @@ describe Lhm::Connection do
   it "Queries should be tagged with ProxySQL tag if reconnect_with_consistent_host is enabled" do
     ar_connection = mock()
     ar_connection.expects(:public_send).with(:select_value, "SHOW TABLES #{Lhm::ProxySQLHelper::ANNOTATION}").returns("dummy")
-    ar_connection.stubs(:execute).times(4).returns([["dummy"]])
+    ar_connection.stubs(:select_value).times(4).returns("dummy")
     ar_connection.stubs(:active?).returns(true)
 
     connection = Lhm::Connection.new(connection: ar_connection, options: {
@@ -108,4 +108,4 @@ describe Lhm::Connection do
 
     assert_equal val, "dummy"
   end
-end
+end

data/spec/unit/entangler_spec.rb

@@ -63,10 +63,9 @@ describe Lhm::Entangler do
     it 'should retry trigger creation when it hits a lock wait timeout' do
       tries = 1
       ar_connection = mock()
+      ar_connection.stubs(:select_value).returns("dummy")
       ar_connection.stubs(:execute)
-                       .returns([["dummy"]], [["dummy"]], [["dummy"]])
-                       .then
-                       .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')
+                   .raises(ActiveRecord::StatementInvalid, 'Lock wait timeout exceeded; try restarting transaction')
       ar_connection.stubs(:active?).returns(true)
 
       connection = Lhm::Connection.new(connection: ar_connection, options: {
@@ -79,15 +78,14 @@ describe Lhm::Entangler do
 
       @entangler = Lhm::Entangler.new(@migration, connection)
 
-      assert_raises(Mysql2::Error) { @entangler.before }
+      assert_raises(ActiveRecord::StatementInvalid) { @entangler.before }
     end
 
     it 'should not retry trigger creation with other mysql errors' do
       ar_connection = mock()
+      ar_connection.stubs(:select_value).returns("dummy")
       ar_connection.stubs(:execute)
-                   .returns([["dummy"]], [["dummy"]], [["dummy"]])
-                   .then
-                   .raises(Mysql2::Error, 'The MySQL server is running with the --read-only option so it cannot execute this statement.')
+                   .raises(DATABASE.error_class, 'The MySQL server is running with the --read-only option so it cannot execute this statement.')
       ar_connection.stubs(:active?).returns(true)
       connection = Lhm::Connection.new(connection: ar_connection, options: {
         reconnect_with_consistent_host: true,
@@ -97,15 +95,14 @@ describe Lhm::Entangler do
       })
 
       @entangler = Lhm::Entangler.new(@migration, connection)
-      assert_raises(Mysql2::Error) { @entangler.before }
+      assert_raises(DATABASE.error_class) { @entangler.before }
     end
 
     it 'should succesfully finish after retrying' do
       ar_connection = mock()
+      ar_connection.stubs(:select_value).returns("dummy")
       ar_connection.stubs(:execute)
-                   .returns([["dummy"]], [["dummy"]], [["dummy"]])
-                   .then
-                   .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')
+                   .raises(ActiveRecord::StatementInvalid, 'Lock wait timeout exceeded; try restarting transaction')
                    .then
                    .returns([["dummy"]])
       ar_connection.stubs(:active?).returns(true)
@@ -124,22 +121,15 @@ describe Lhm::Entangler do
 
     it 'should retry as many times as specified by configuration' do
       ar_connection = mock()
+      ar_connection.stubs(:select_value).returns("dummy")
       ar_connection.stubs(:execute)
-                   .returns([["dummy"]], [["dummy"]], [["dummy"]]) # initial
-                   .then
-                   .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')
-                   .then
-                   .returns([["dummy"]]) # reconnect 1
-                   .then
-                   .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')
-                   .then
-                   .returns([["dummy"]])  # reconnect 2
+                   .raises(DATABASE.error_class, 'Lock wait timeout exceeded; try restarting transaction')
                    .then
-                   .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')
+                   .raises(DATABASE.error_class, 'Lock wait timeout exceeded; try restarting transaction')
                    .then
-                   .returns([["dummy"]])  # reconnect 3
+                   .raises(DATABASE.error_class, 'Lock wait timeout exceeded; try restarting transaction')
                    .then
-                   .raises(Mysql2::Error, 'Lock wait timeout exceeded; try restarting transaction')  # final error
+                   .raises(DATABASE.error_class, 'Lock wait timeout exceeded; try restarting transaction')  # final error
       ar_connection.stubs(:active?).returns(true)
 
       connection = Lhm::Connection.new(connection: ar_connection, options: {
@@ -152,7 +142,7 @@ describe Lhm::Entangler do
 
       @entangler = Lhm::Entangler.new(@migration, connection)
 
-      assert_raises(Mysql2::Error) { @entangler.before }
+      assert_raises(DATABASE.error_class) { @entangler.before }
     end
 
     describe 'super long table names' do

data/spec/unit/printer_spec.rb

@@ -70,15 +70,11 @@ describe Lhm::Printer do
     end
 
     it 'prints the dots' do
-      mock  = MiniTest::Mock.new
-      10.times do
-        mock.expect(:write, :return_value, ['.'])
-      end
+      mock  = mock("output")
+      mock.expects(:write).with('.').times(10)
 
       @printer.instance_variable_set(:@output, mock)
       10.times { @printer.notify }
-
-      mock.verify
     end
 
   end

data/spec/unit/sql_helper_spec.rb

@@ -22,7 +22,7 @@ describe Lhm::SqlHelper do
   end
 
   it 'should quote column names in index specification' do
-    value(Lhm::SqlHelper.idx_spec(['title(10)', 'album']))
-      .must_equal('`title`(10), `album`')
+    value(Lhm::SqlHelper.idx_spec(['title(10)', 'name (6)', 'album']))
+      .must_equal('`title`(10), `name`(6), `album`')
   end
 end