lhm 1.2.0 → 2.2.0

data/spec/unit/chunker_spec.rb

@@ -6,106 +6,128 @@ require File.expand_path(File.dirname(__FILE__)) + '/unit_helper'
 require 'lhm/table'
 require 'lhm/migration'
 require 'lhm/chunker'
+require 'lhm/throttler'
 
 describe Lhm::Chunker do
   include UnitHelper
 
   before(:each) do
-    @origin      = Lhm::Table.new("origin")
-    @destination = Lhm::Table.new("destination")
-    @migration   = Lhm::Migration.new(@origin, @destination)
-    @chunker     = Lhm::Chunker.new(@migration, nil, { :start => 1, :limit => 10 })
+    @origin = Lhm::Table.new('foo')
+    @destination = Lhm::Table.new('bar')
+    @migration = Lhm::Migration.new(@origin, @destination)
+    @connection = MiniTest::Mock.new
+    # This is a poor man's stub
+    @throttler = Object.new
+    def @throttler.run
+      # noop
+    end
+    def @throttler.stride
+      1
+    end
+    @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                         :start     => 1,
+                                                         :limit     => 10)
   end
 
-  describe "copy into" do
-    before(:each) do
-      @origin.columns["secret"] = { :metadata => "VARCHAR(255)"}
-      @destination.columns["secret"] = { :metadata => "VARCHAR(255)"}
-    end
-
-    it "should copy the correct range and column" do
-      @chunker.copy(from = 1, to = 100).must_equal(
-        "insert ignore into `destination` (`secret`) " +
-        "select `secret` from `origin` " +
-        "where `id` between 1 and 100"
-      )
-    end
-  end
+  describe '#run' do
+    it 'chunks the result set according to the stride size' do
+      def @throttler.stride
+        2
+      end
 
-  describe "invalid" do
-    before do
-      @chunker = Lhm::Chunker.new(@migration, nil, { :start => 0, :limit => -1 })
-    end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 1 and 2/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 3 and 4/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 5 and 6/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 7 and 8/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 9 and 10/
+      end
 
-    it "should have zero chunks" do
-      @chunker.traversable_chunks_size.must_equal 0
+      @chunker.run
+      @connection.verify
     end
 
-    it "should not iterate" do
-      @chunker.up_to do |bottom, top|
-        raise "should not iterate"
+    it 'handles stride changes during execution' do
+      # roll our own stubbing
+      def @throttler.stride
+        @run_count ||= 0
+        @run_count = @run_count + 1
+        if @run_count > 1
+          3
+        else
+          2
+        end
       end
-    end
-  end
 
-  describe "one" do
-    before do
-      @chunker = Lhm::Chunker.new(@migration, nil, {
-        :stride => 100_000, :start => 1, :limit => 300_000
-      })
-    end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 1 and 2/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 3 and 5/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 6 and 8/
+      end
+      @connection.expect(:update, 2) do |stmt|
+        stmt.first =~ /between 9 and 10/
+      end
 
-    it "should have one chunk" do
-      @chunker.traversable_chunks_size.must_equal 3
+      @chunker.run
+      @connection.verify
     end
 
-    it "should lower bound chunk on 1" do
-      @chunker.bottom(chunk = 1).must_equal 1
-    end
+    it 'correctly copies single record tables' do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :start     => 1,
+                                                           :limit     => 1)
 
-    it "should upper bound chunk on 100" do
-      @chunker.top(chunk = 1).must_equal 100_000
-    end
-  end
+      @connection.expect(:update, 1) do |stmt|
+        stmt.first =~ /between 1 and 1/
+      end
 
-  describe "two" do
-    before do
-      @chunker = Lhm::Chunker.new(@migration, nil, {
-        :stride => 100_000, :start => 2, :limit => 150_000
-      })
+      @chunker.run
+      @connection.verify
     end
 
-    it "should have two chunks" do
-      @chunker.traversable_chunks_size.must_equal 2
-    end
+    it 'separates filter conditions from chunking conditions' do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :start     => 1,
+                                                           :limit     => 2)
+      @connection.expect(:update, 1) do |stmt|
+        stmt.first =~ /where \(foo.created_at > '2013-07-10' or foo.baz = 'quux'\) and `foo`/
+      end
 
-    it "should lower bound second chunk on 100_000" do
-      @chunker.bottom(chunk = 2).must_equal 100_002
-    end
+      def @migration.conditions
+        "where foo.created_at > '2013-07-10' or foo.baz = 'quux'"
+      end
 
-    it "should upper bound second chunk on 150_000" do
-      @chunker.top(chunk = 2).must_equal 150_000
+      @chunker.run
+      @connection.verify
     end
-  end
 
-  describe "iterating" do
-    before do
-      @chunker = Lhm::Chunker.new(@migration, nil, {
-        :stride => 100, :start => 53, :limit => 121
-      })
-    end
+    it "doesn't mess with inner join filters" do
+      @chunker = Lhm::Chunker.new(@migration, @connection, :throttler => @throttler,
+                                                           :start     => 1,
+                                                           :limit     => 2)
+      @connection.expect(:update, 1) do |stmt|
+        puts stmt
+        stmt.first =~ /inner join bar on foo.id = bar.foo_id and/
+      end
 
-    it "should iterate" do
-      @chunker.up_to do |bottom, top|
-        bottom.must_equal 53
-        top.must_equal 121
+      def @migration.conditions
+        'inner join bar on foo.id = bar.foo_id'
       end
-    end
-  end
 
-  describe "throttling" do
-    it "should default to 100 milliseconds" do
-      @chunker.throttle_seconds.must_equal 0.1
+      @chunker.run
+      @connection.verify
     end
   end
 end

data/spec/unit/datamapper_connection_spec.rb

@@ -11,6 +11,7 @@ if defined?(DataMapper)
     before do
       data_mapper.expect :is_a?, true, [DataMapper::Adapters::AbstractAdapter]
       data_mapper.expect :options, options
+      data_mapper.expect :options, options
     end
 
     after do

data/spec/unit/entangler_spec.rb

@@ -11,44 +11,44 @@ describe Lhm::Entangler do
   include UnitHelper
 
   before(:each) do
-    @origin = Lhm::Table.new("origin")
-    @destination = Lhm::Table.new("destination")
+    @origin = Lhm::Table.new('origin')
+    @destination = Lhm::Table.new('destination')
     @migration = Lhm::Migration.new(@origin, @destination)
     @entangler = Lhm::Entangler.new(@migration)
   end
 
-  describe "activation" do
+  describe 'activation' do
     before(:each) do
-      @origin.columns["info"] = { :type => "varchar(255)" }
-      @origin.columns["tags"] = { :type => "varchar(255)" }
+      @origin.columns['info'] = { :type => 'varchar(255)' }
+      @origin.columns['tags'] = { :type => 'varchar(255)' }
 
-      @destination.columns["info"] = { :type => "varchar(255)" }
-      @destination.columns["tags"] = { :type => "varchar(255)" }
+      @destination.columns['info'] = { :type => 'varchar(255)' }
+      @destination.columns['tags'] = { :type => 'varchar(255)' }
     end
 
-    it "should create insert trigger to destination table" do
+    it 'should create insert trigger to destination table' do
       ddl = %Q{
         create trigger `lhmt_ins_origin`
         after insert on `origin` for each row
         replace into `destination` (`info`, `tags`) /* large hadron migration */
-        values (NEW.`info`, NEW.`tags`)
+        values (`NEW`.`info`, `NEW`.`tags`)
       }
 
       @entangler.entangle.must_include strip(ddl)
     end
 
-    it "should create an update trigger to the destination table" do
+    it 'should create an update trigger to the destination table' do
       ddl = %Q{
         create trigger `lhmt_upd_origin`
         after update on `origin` for each row
         replace into `destination` (`info`, `tags`) /* large hadron migration */
-        values (NEW.`info`, NEW.`tags`)
+        values (`NEW`.`info`, `NEW`.`tags`)
       }
 
       @entangler.entangle.must_include strip(ddl)
     end
 
-    it "should create a delete trigger to the destination table" do
+    it 'should create a delete trigger to the destination table' do
       ddl = %Q{
         create trigger `lhmt_del_origin`
         after delete on `origin` for each row
@@ -60,17 +60,17 @@ describe Lhm::Entangler do
     end
   end
 
-  describe "removal" do
-    it "should remove insert trigger" do
-      @entangler.untangle.must_include("drop trigger if exists `lhmt_ins_origin`")
+  describe 'removal' do
+    it 'should remove insert trigger' do
+      @entangler.untangle.must_include('drop trigger if exists `lhmt_ins_origin`')
     end
 
-    it "should remove update trigger" do
-      @entangler.untangle.must_include("drop trigger if exists `lhmt_upd_origin`")
+    it 'should remove update trigger' do
+      @entangler.untangle.must_include('drop trigger if exists `lhmt_upd_origin`')
     end
 
-    it "should remove delete trigger" do
-      @entangler.untangle.must_include("drop trigger if exists `lhmt_del_origin`")
+    it 'should remove delete trigger' do
+      @entangler.untangle.must_include('drop trigger if exists `lhmt_del_origin`')
     end
   end
 end

data/spec/unit/intersection_spec.rb

@@ -9,31 +9,43 @@ require 'lhm/migrator'
 describe Lhm::Intersection do
   include UnitHelper
 
-  it "should not have dropped changes" do
-    origin = Lhm::Table.new("origin")
-    origin.columns["dropped"]  = varchar
-    origin.columns["retained"] = varchar
+  it 'should not have dropped changes' do
+    origin = Lhm::Table.new('origin')
+    origin.columns['dropped']  = varchar
+    origin.columns['retained'] = varchar
 
-    destination = Lhm::Table.new("destination")
-    destination.columns["retained"] = varchar
+    destination = Lhm::Table.new('destination')
+    destination.columns['retained'] = varchar
 
     intersection = Lhm::Intersection.new(origin, destination)
-    intersection.common.include?("dropped").must_equal(false)
+    intersection.destination.include?('dropped').must_equal(false)
   end
 
-  it "should have unchanged columns" do
-    origin = Lhm::Table.new("origin")
-    origin.columns["dropped"]  = varchar
-    origin.columns["retained"] = varchar
+  it 'should have unchanged columns' do
+    origin = Lhm::Table.new('origin')
+    origin.columns['dropped']  = varchar
+    origin.columns['retained'] = varchar
 
-    destination = Lhm::Table.new("destination")
-    destination.columns["retained"] = varchar
+    destination = Lhm::Table.new('destination')
+    destination.columns['retained'] = varchar
 
     intersection = Lhm::Intersection.new(origin, destination)
-    intersection.common.must_equal(["retained"])
+    intersection.destination.must_equal(['retained'])
+  end
+
+  it 'should have renamed columns' do
+    origin = Lhm::Table.new('origin')
+    origin.columns['old_name']  = varchar
+
+    destination = Lhm::Table.new('destination')
+    destination.columns['new_name'] = varchar
+
+    intersection = Lhm::Intersection.new(origin, destination, { 'old_name' => 'new_name' })
+    intersection.origin.must_equal(['old_name'])
+    intersection.destination.must_equal(['new_name'])
   end
 
   def varchar
-    { :metadata => "VARCHAR(255)"}
+    { :metadata => 'VARCHAR(255)' }
   end
 end

data/spec/unit/lhm_spec.rb

@@ -0,0 +1,29 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd.
+
+require File.expand_path(File.dirname(__FILE__)) + '/unit_helper'
+
+describe Lhm do
+
+  before(:each) do
+    Lhm.remove_class_variable :@@logger if Lhm.class_variable_defined? :@@logger
+  end
+
+  describe 'logger' do
+
+    it 'should use the default parameters if no logger explicitly set' do
+      Lhm.logger.must_be_kind_of Logger
+      Lhm.logger.level.must_equal Logger::INFO
+      Lhm.logger.instance_eval { @logdev }.dev.must_equal STDOUT
+    end
+
+    it 'should use s new logger if set' do
+      l = Logger.new('omg.ponies')
+      l.level = Logger::ERROR
+      Lhm.logger = l
+
+      Lhm.logger.level.must_equal Logger::ERROR
+      Lhm.logger.instance_eval { @logdev }.dev.must_be_kind_of File
+      Lhm.logger.instance_eval { @logdev }.dev.path.must_equal 'omg.ponies'
+    end
+  end
+end

data/spec/unit/locked_switcher_spec.rb

@@ -12,39 +12,39 @@ describe Lhm::LockedSwitcher do
 
   before(:each) do
     @start       = Time.now
-    @origin      = Lhm::Table.new("origin")
-    @destination = Lhm::Table.new("destination")
+    @origin      = Lhm::Table.new('origin')
+    @destination = Lhm::Table.new('destination')
     @migration   = Lhm::Migration.new(@origin, @destination, @start)
     @switcher    = Lhm::LockedSwitcher.new(@migration, nil)
   end
 
-  describe "uncommitted" do
-    it "should disable autocommit first" do
+  describe 'uncommitted' do
+    it 'should disable autocommit first' do
       @switcher.
         statements[0..1].
         must_equal([
-          "set @lhm_auto_commit = @@session.autocommit",
-          "set session autocommit = 0"
+          'set @lhm_auto_commit = @@session.autocommit',
+          'set session autocommit = 0'
         ])
     end
 
-    it "should reapply original autocommit settings at the end" do
+    it 'should reapply original autocommit settings at the end' do
       @switcher.
         statements[-1].
-        must_equal("set session autocommit = @lhm_auto_commit")
+        must_equal('set session autocommit = @lhm_auto_commit')
     end
   end
 
-  describe "switch" do
-    it "should lock origin and destination table, switch, commit and unlock" do
+  describe 'switch' do
+    it 'should lock origin and destination table, switch, commit and unlock' do
       @switcher.
         switch.
         must_equal([
-          "lock table `origin` write, `destination` write",
+          'lock table `origin` write, `destination` write',
           "alter table `origin` rename `#{ @migration.archive_name }`",
-          "alter table `destination` rename `origin`",
-          "commit",
-          "unlock tables"
+          'alter table `destination` rename `origin`',
+          'commit',
+          'unlock tables'
         ])
     end
   end

data/spec/unit/migration_spec.rb

@@ -11,13 +11,18 @@ describe Lhm::Migration do
 
   before(:each) do
     @start = Time.now
-    @origin = Lhm::Table.new("origin")
-    @destination = Lhm::Table.new("destination")
-    @migration = Lhm::Migration.new(@origin, @destination, @start)
+    @origin = Lhm::Table.new('origin')
+    @destination = Lhm::Table.new('destination')
+    @migration = Lhm::Migration.new(@origin, @destination, nil, @start)
   end
 
-  it "should name archive" do
-    stamp = "%Y_%m_%d_%H_%M_%S_#{ "%03d" % (@start.usec / 1000) }"
+  it 'should name archive' do
+    stamp = "%Y_%m_%d_%H_%M_%S_#{ '%03d' % (@start.usec / 1000) }"
     @migration.archive_name.must_equal "lhma_#{ @start.strftime(stamp) }_origin"
   end
+
+  it 'should limit table name to 64 characters' do
+    migration = Lhm::Migration.new(OpenStruct.new(:name => 'a_very_very_long_table_name_that_should_make_the_LHMA_table_go_over_64_chars'), nil)
+    migration.archive_name.size == 64
+  end
 end

data/spec/unit/migrator_spec.rb

@@ -10,125 +10,137 @@ describe Lhm::Migrator do
   include UnitHelper
 
   before(:each) do
-    @table = Lhm::Table.new("alt")
+    @table = Lhm::Table.new('alt')
     @creator = Lhm::Migrator.new(@table)
   end
 
-  describe "index changes" do
-    it "should add an index" do
+  describe 'index changes' do
+    it 'should add an index' do
       @creator.add_index(:a)
 
       @creator.statements.must_equal([
-        "create index `index_alt_on_a` on `lhmn_alt` (`a`)"
+        'create index `index_alt_on_a` on `lhmn_alt` (`a`)'
       ])
     end
 
-    it "should add a composite index" do
+    it 'should add a composite index' do
       @creator.add_index([:a, :b])
 
       @creator.statements.must_equal([
-        "create index `index_alt_on_a_and_b` on `lhmn_alt` (`a`, `b`)"
+        'create index `index_alt_on_a_and_b` on `lhmn_alt` (`a`, `b`)'
       ])
     end
 
-    it "should add an index with prefix length" do
-      @creator.add_index(["a(10)", "b"])
+    it 'should add an index with prefix length' do
+      @creator.add_index(['a(10)', 'b'])
 
       @creator.statements.must_equal([
-        "create index `index_alt_on_a_and_b` on `lhmn_alt` (`a`(10), `b`)"
+        'create index `index_alt_on_a_and_b` on `lhmn_alt` (`a`(10), `b`)'
       ])
     end
 
-    it "should add an index with a custom name" do
+    it 'should add an index with a custom name' do
       @creator.add_index([:a, :b], :custom_index_name)
 
       @creator.statements.must_equal([
-        "create index `custom_index_name` on `lhmn_alt` (`a`, `b`)"
+        'create index `custom_index_name` on `lhmn_alt` (`a`, `b`)'
       ])
     end
 
-    it "should add a unique index" do
-      @creator.add_unique_index(["a(5)", :b])
+    it 'should raise an error when the index name is not a string or symbol' do
+      assert_raises ArgumentError do
+        @creator.add_index([:a, :b], :name => :custom_index_name)
+      end
+    end
+
+    it 'should add a unique index' do
+      @creator.add_unique_index(['a(5)', :b])
 
       @creator.statements.must_equal([
-        "create unique index `index_alt_on_a_and_b` on `lhmn_alt` (`a`(5), `b`)"
+        'create unique index `index_alt_on_a_and_b` on `lhmn_alt` (`a`(5), `b`)'
       ])
     end
 
-    it "should add a unique index with a custom name" do
+    it 'should add a unique index with a custom name' do
       @creator.add_unique_index([:a, :b], :custom_index_name)
 
       @creator.statements.must_equal([
-        "create unique index `custom_index_name` on `lhmn_alt` (`a`, `b`)"
+        'create unique index `custom_index_name` on `lhmn_alt` (`a`, `b`)'
       ])
     end
 
-    it "should remove an index" do
-      @creator.remove_index(["b", "a"])
+    it 'should raise an error when the unique index name is not a string or symbol' do
+      assert_raises ArgumentError do
+        @creator.add_unique_index([:a, :b], :name => :custom_index_name)
+      end
+    end
+
+    it 'should remove an index' do
+      @creator.remove_index(['b', 'a'])
 
       @creator.statements.must_equal([
-        "drop index `index_alt_on_b_and_a` on `lhmn_alt`"
+        'drop index `index_alt_on_b_and_a` on `lhmn_alt`'
       ])
     end
 
-    it "should remove an index with a custom name" do
+    it 'should remove an index with a custom name' do
       @creator.remove_index([:a, :b], :custom_index_name)
 
       @creator.statements.must_equal([
-        "drop index `custom_index_name` on `lhmn_alt`"
+        'drop index `custom_index_name` on `lhmn_alt`'
       ])
     end
   end
 
-  describe "column changes" do
-    it "should add a column" do
-      @creator.add_column("logins", "INT(12)")
+  describe 'column changes' do
+    it 'should add a column' do
+      @creator.add_column('logins', 'INT(12)')
 
       @creator.statements.must_equal([
-        "alter table `lhmn_alt` add column `logins` INT(12)"
+        'alter table `lhmn_alt` add column `logins` INT(12)'
       ])
     end
 
-    it "should remove a column" do
-      @creator.remove_column("logins")
+    it 'should remove a column' do
+      @creator.remove_column('logins')
 
       @creator.statements.must_equal([
-        "alter table `lhmn_alt` drop `logins`"
+        'alter table `lhmn_alt` drop `logins`'
       ])
     end
 
-    it "should change a column" do
-      @creator.change_column("logins", "INT(11)")
+    it 'should change a column' do
+      @creator.change_column('logins', 'INT(11)')
 
       @creator.statements.must_equal([
-        "alter table `lhmn_alt` modify column `logins` INT(11)"
+        'alter table `lhmn_alt` modify column `logins` INT(11)'
       ])
     end
   end
 
-  describe "direct changes" do
-    it "should accept a ddl statement" do
-     ddl = @creator.ddl("alter table `%s` add column `f` tinyint(1)" % @creator.name)
+  describe 'direct changes' do
+    it 'should accept a ddl statement' do
+     ddl = @creator.ddl('alter table `%s` add column `f` tinyint(1)' % @creator.name)
 
      @creator.statements.must_equal([
-       "alter table `lhmn_alt` add column `f` tinyint(1)"
+       'alter table `lhmn_alt` add column `f` tinyint(1)'
      ])
     end
   end
 
-  describe "multiple changes" do
-    it "should add two columns" do
-      @creator.add_column("first", "VARCHAR(64)")
-      @creator.add_column("last", "VARCHAR(64)")
+  describe 'multiple changes' do
+    it 'should add two columns' do
+      @creator.add_column('first', 'VARCHAR(64)')
+      @creator.add_column('last', 'VARCHAR(64)')
       @creator.statements.length.must_equal(2)
 
       @creator.
         statements[0].
-        must_equal("alter table `lhmn_alt` add column `first` VARCHAR(64)")
+        must_equal('alter table `lhmn_alt` add column `first` VARCHAR(64)')
 
       @creator.
         statements[1].
-        must_equal("alter table `lhmn_alt` add column `last` VARCHAR(64)")
+        must_equal('alter table `lhmn_alt` add column `last` VARCHAR(64)')
     end
   end
 end