lhm-shopify 3.3.5

data/spec/integration/cleanup_spec.rb

@@ -0,0 +1,136 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+
+describe Lhm, 'cleanup' do
+  include IntegrationHelper
+  before(:each) { connect_master! }
+
+  describe 'changes' do
+    before(:each) do
+      table_create(:users)
+      table_create(:permissions)
+      simulate_failed_migration do
+        Lhm.change_table(:users, :atomic_switch => false) do |t|
+          t.add_column(:logins, "INT(12) DEFAULT '0'")
+          t.add_index(:logins)
+        end
+      end
+      simulate_failed_migration do
+        Lhm.change_table(:permissions, :atomic_switch => false) do |t|
+          t.add_column(:user_id, "INT(12) DEFAULT '0'")
+          t.add_index(:user_id)
+        end
+      end
+    end
+
+    after(:each) do
+      Lhm.cleanup(true)
+    end
+
+    describe 'cleanup' do
+      it 'should show temporary tables' do
+        output = capture_stdout do
+          Lhm.cleanup
+        end
+        output.must_include('Would drop LHM backup tables')
+        output.must_match(/lhma_[0-9_]*_users/)
+        output.must_match(/lhma_[0-9_]*_permissions/)
+      end
+
+      it 'should show temporary tables within range' do
+        table = OpenStruct.new(:name => 'users')
+        table_name = Lhm::Migration.new(table, nil, nil, {}, Time.now - 172800).archive_name
+        table_rename(:users, table_name)
+
+        table2 = OpenStruct.new(:name => 'permissions')
+        table_name2 = Lhm::Migration.new(table2, nil, nil, {}, Time.now - 172800).archive_name
+        table_rename(:permissions, table_name2)
+
+        output = capture_stdout do
+          Lhm.cleanup false, { :until => Time.now - 86400 }
+        end
+        output.must_include('Would drop LHM backup tables')
+        output.must_match(/lhma_[0-9_]*_users/)
+        output.must_match(/lhma_[0-9_]*_permissions/)
+      end
+
+      it 'should exclude temporary tables outside range' do
+        table = OpenStruct.new(:name => 'users')
+        table_name = Lhm::Migration.new(table, nil, nil, {}, Time.now).archive_name
+        table_rename(:users, table_name)
+
+        table2 = OpenStruct.new(:name => 'permissions')
+        table_name2 = Lhm::Migration.new(table2, nil, nil, {}, Time.now).archive_name
+        table_rename(:permissions, table_name2)
+
+        output = capture_stdout do
+          Lhm.cleanup false, { :until => Time.now - 172800 }
+        end
+        output.must_include('Would drop LHM backup tables')
+        output.wont_match(/lhma_[0-9_]*_users/)
+        output.wont_match(/lhma_[0-9_]*_permissions/)
+      end
+
+      it 'should show temporary triggers' do
+        output = capture_stdout do
+          Lhm.cleanup
+        end
+        output.must_include('Would drop LHM triggers')
+        output.must_include('lhmt_ins_users')
+        output.must_include('lhmt_del_users')
+        output.must_include('lhmt_upd_users')
+        output.must_include('lhmt_ins_permissions')
+        output.must_include('lhmt_del_permissions')
+        output.must_include('lhmt_upd_permissions')
+      end
+
+      it 'should delete temporary tables' do
+        Lhm.cleanup(true).must_equal(true)
+        Lhm.cleanup.must_equal(true)
+      end
+    end
+
+    describe 'cleanup_current_run' do
+      it 'should show lhmn table for the specified table only' do
+        table_create(:permissions)
+        table_rename(:permissions, 'lhmn_permissions')
+        output = capture_stdout do
+          Lhm.cleanup_current_run(false, 'permissions')
+        end.split("\n")
+
+        assert_equal "The following DDLs would be executed:", output[0]
+        assert_equal "drop trigger if exists lhmt_ins_permissions", output[1]
+        assert_equal "drop trigger if exists lhmt_upd_permissions", output[2]
+        assert_equal "drop trigger if exists lhmt_del_permissions", output[3]
+        assert_match(/rename table lhmn_permissions to lhma_[0-9_]*_permissions_failed/, output[4])
+        assert_equal 5, output.length
+      end
+
+      it 'should show temporary triggers for the specified table only' do
+        output = capture_stdout do
+          Lhm.cleanup_current_run(false, 'permissions')
+        end.split("\n")
+        assert_equal "The following DDLs would be executed:", output[0]
+        assert_equal "drop trigger if exists lhmt_ins_permissions", output[1]
+        assert_equal "drop trigger if exists lhmt_upd_permissions", output[2]
+        assert_equal "drop trigger if exists lhmt_del_permissions", output[3]
+        assert_equal 4, output.length
+      end
+
+      it 'should delete temporary tables and triggers for the specified table only' do
+        assert Lhm.cleanup_current_run(true, 'permissions')
+
+        all_tables = Lhm.connection.select_values('show tables')
+        all_triggers = Lhm.connection.select_values('show triggers')
+
+        refute all_tables.include?('lhmn_permissions')
+        assert all_tables.find { |t| t =~ /lhma_(.*)_users/}
+
+        refute all_triggers.find { |t| t =~ /lhmt_(.*)_permissions/}
+        assert all_triggers.find { |t| t =~ /lhmt_(.*)_users/}
+      end
+    end
+  end
+end

data/spec/integration/entangler_spec.rb

@@ -0,0 +1,66 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+
+require 'lhm/table'
+require 'lhm/migration'
+require 'lhm/entangler'
+
+describe Lhm::Entangler do
+  include IntegrationHelper
+
+  before(:each) { connect_master! }
+
+  describe 'entanglement' do
+    before(:each) do
+      @origin = table_create('origin')
+      @destination = table_create('destination')
+      @migration = Lhm::Migration.new(@origin, @destination)
+      @entangler = Lhm::Entangler.new(@migration, connection)
+    end
+
+    it 'should replay inserts from origin into destination' do
+      @entangler.run do
+        execute("insert into origin (common) values ('inserted')")
+      end
+
+      slave do
+        count(:destination, 'common', 'inserted').must_equal(1)
+      end
+    end
+
+    it 'should replay deletes from origin into destination' do
+      execute("insert into origin (common) values ('inserted')")
+
+      @entangler.run do
+        execute("delete from origin where common = 'inserted'")
+      end
+
+      slave do
+        count(:destination, 'common', 'inserted').must_equal(0)
+      end
+    end
+
+    it 'should replay updates from origin into destination' do
+      @entangler.run do
+        execute("insert into origin (common) values ('inserted')")
+        execute("update origin set common = 'updated'")
+      end
+
+      slave do
+        count(:destination, 'common', 'updated').must_equal(1)
+      end
+    end
+
+    it 'should remove entanglement' do
+      @entangler.run {}
+
+      execute("insert into origin (common) values ('inserted')")
+
+      slave do
+        count(:destination, 'common', 'inserted').must_equal(0)
+      end
+    end
+  end
+end

data/spec/integration/integration_helper.rb

@@ -0,0 +1,237 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+require 'test_helper'
+require 'yaml'
+require 'active_support'
+
+begin
+  $db_config = YAML.load_file(File.expand_path(File.dirname(__FILE__)) + '/database.yml')
+rescue StandardError => e
+  puts "Run install.sh to setup database"
+  raise e
+end
+
+$db_name = 'test'
+
+require 'lhm/table'
+require 'lhm/sql_helper'
+
+module IntegrationHelper
+
+  def self.included(base)
+    base.after(:each) do
+      cleanup_connection = new_mysql_connection
+      results = cleanup_connection.query("SELECT table_name FROM information_schema.tables WHERE table_schema = '#{$db_name}';")
+      table_names_for_cleanup = results.map { |row| "#{$db_name}." + row.values.first }
+      cleanup_connection.query("DROP TABLE IF EXISTS #{table_names_for_cleanup.join(', ')};") if table_names_for_cleanup.length > 0
+    end
+  end
+
+  #
+  # Connectivity
+  #
+  def connection
+    @connection
+  end
+
+  def connect_master!
+    connect!(
+      '127.0.0.1',
+      $db_config['master']['port'],
+      $db_config['master']['user'],
+      $db_config['master']['password'],
+      $db_config['master']['socket']
+    )
+  end
+
+  def connect_slave!
+    connect!(
+      '127.0.0.1',
+      $db_config['slave']['port'],
+      $db_config['slave']['user'],
+      $db_config['slave']['password'],
+      $db_config['slave']['socket']
+    )
+  end
+
+  def connect!(hostname, port, user, password, socket)
+    adapter = ar_conn(hostname, port, user, password, socket)
+    Lhm.setup(adapter)
+    unless defined?(@@cleaned_up)
+      Lhm.cleanup(true)
+      @@cleaned_up  = true
+    end
+    @connection = adapter
+  end
+
+  def ar_conn(host, port, user, password, socket)
+    ActiveRecord::Base.establish_connection(
+      :adapter  => 'mysql2',
+      :host     => host,
+      :username => user,
+      :port     => port,
+      :password => password,
+      :socket   => socket,
+      :database => $db_name
+    )
+    ActiveRecord::Base.connection
+  end
+
+  def select_one(*args)
+    @connection.select_one(*args)
+  end
+
+  def select_value(*args)
+    @connection.select_value(*args)
+  end
+
+  def execute(*args)
+    retries = 10
+    begin
+      @connection.execute(*args)
+    rescue => e
+      if (retries -= 1) > 0 && e.message =~ /Table '.*?' doesn't exist/
+        sleep 0.1
+        retry
+      else
+        raise
+      end
+    end
+  end
+
+  def slave(&block)
+    if master_slave_mode?
+      connect_slave!
+
+      # need to wait for the slave to catch up. a better method would be to
+      # check the master binlog position and wait for the slave to catch up
+      # to that position.
+      sleep 1
+    else
+      connect_master!
+    end
+
+    yield block
+
+    if master_slave_mode?
+      connect_master!
+    end
+  end
+
+  # Helps testing behaviour when another client locks the db
+  def start_locking_thread(lock_for, queue, locking_query)
+    Thread.new do
+      conn = Mysql2::Client.new(host: '127.0.0.1', database: $db_name, user: 'root', port: 3306)
+      conn.query('BEGIN')
+      conn.query(locking_query)
+      queue.push(true)
+      sleep(lock_for) # Sleep for log so LHM gives up
+      conn.query('ROLLBACK')
+    end
+  end
+
+  #
+  # Test Data
+  #
+
+  def fixture(name)
+    File.read($fixtures.join("#{ name }.ddl"))
+  end
+
+  def table_create(fixture_name)
+    execute "drop table if exists `#{ fixture_name }`"
+    execute fixture(fixture_name)
+    table_read(fixture_name)
+  end
+
+  def table_rename(from_name, to_name)
+    execute "rename table `#{ from_name }` to `#{ to_name }`"
+  end
+
+  def table_read(fixture_name)
+    Lhm::Table.parse(fixture_name, @connection)
+  end
+
+  def data_source_exists?(table)
+    connection.data_source_exists?(table.name)
+  end
+
+  def new_mysql_connection(role='master')
+    Mysql2::Client.new(
+      host: '127.0.0.1',
+      database: $db_name,
+      username: $db_config[role]['user'],
+      password: $db_config[role]['password'],
+      port: $db_config[role]['port'],
+      socket: $db_config[role]['socket']
+    )
+  end
+
+  #
+  # Database Helpers
+  #
+
+  def count(table, column, value)
+    query = "select count(*) from #{ table } where #{ column } = '#{ value }'"
+    select_value(query).to_i
+  end
+
+  def count_all(table)
+    query = "select count(*) from `#{ table }`"
+    select_value(query).to_i
+  end
+
+  def index_on_columns?(table_name, cols, type = :non_unique)
+    key_name = Lhm::SqlHelper.idx_name(table_name, cols)
+
+    index?(table_name, key_name, type)
+  end
+
+  def index?(table_name, key_name, type = :non_unique)
+    non_unique = type == :non_unique ? 1 : 0
+
+    !!select_one(%Q<
+      show indexes in `#{ table_name }`
+     where key_name = '#{ key_name }'
+       and non_unique = #{ non_unique }
+    >)
+  end
+
+  #
+  # Environment
+  #
+
+  def master_slave_mode?
+    !!ENV['MASTER_SLAVE']
+  end
+
+  #
+  # Misc
+  #
+
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    return out.string
+  ensure
+    $stdout = ::STDOUT
+  end
+
+  def simulate_failed_migration
+    Lhm::Entangler.class_eval do
+      alias_method :old_after, :after
+      def after
+        true
+      end
+    end
+
+    yield
+  ensure
+    Lhm::Entangler.class_eval do
+      undef_method :after
+      alias_method :after, :old_after
+      undef_method :old_after
+    end
+  end
+end

data/spec/integration/invoker_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+
+require 'lhm/invoker'
+
+describe Lhm::Invoker do
+  include IntegrationHelper
+
+  before(:each) do
+    connect_master!
+    @origin = table_create('users')
+    @destination = table_create('destination')
+    @invoker = Lhm::Invoker.new(Lhm::Table.parse(:users, @connection), @connection)
+    @migration = Lhm::Migration.new(@origin, @destination)
+    @entangler = Lhm::Entangler.new(@migration, @connection)
+    @entangler.before
+  end
+
+  after(:each) do
+    @entangler.after if @invoker.triggers_still_exist?(@invoker.connection, @entangler)
+  end
+
+  describe 'triggers_still_exist?' do
+    it 'should return true when triggers still exist' do
+      assert @invoker.triggers_still_exist?(@invoker.connection, @entangler)
+    end
+
+    it 'should return false when triggers do not exist' do
+      @entangler.after
+
+      refute @invoker.triggers_still_exist?(@invoker.connection, @entangler)
+    end
+  end
+end