rubyrep 1.0.9 → 1.1.0

data/spec/syncers_spec.rb

@@ -101,7 +101,7 @@ describe Syncers::OneWaySyncer do
     helper = SyncHelper.new(sync)
     helper.stub!(:sync_options).and_return({:direction => :left, :delete => true})
     syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:left, :dummy_record)
+    helper.should_receive(:delete_record).with(:left, 'scanner_records', :dummy_record)
     helper.should_not_receive(:update_record)
     helper.should_not_receive(:insert_record)
     syncer.sync_difference(:left, :dummy_record)
@@ -109,7 +109,7 @@ describe Syncers::OneWaySyncer do
     helper = SyncHelper.new(sync)
     helper.stub!(:sync_options).and_return({:direction => :right, :delete => true})
     syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:right, :dummy_record)
+    helper.should_receive(:delete_record).with(:right, 'scanner_records', :dummy_record)
     syncer.sync_difference(:right, :dummy_record)
   end
 
@@ -131,13 +131,13 @@ describe Syncers::OneWaySyncer do
     syncer = Syncers::OneWaySyncer.new(helper)
     helper.should_not_receive(:delete_record)
     helper.should_not_receive(:update_record)
-    helper.should_receive(:insert_record).with(:left, :dummy_record)
+    helper.should_receive(:insert_record).with(:left, 'scanner_records', :dummy_record)
     syncer.sync_difference(:right, :dummy_record)
 
     helper = SyncHelper.new(sync)
     helper.stub!(:sync_options).and_return({:direction => :right, :insert => true})
     syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:insert_record).with(:right, :dummy_record)
+    helper.should_receive(:insert_record).with(:right, 'scanner_records', :dummy_record)
     syncer.sync_difference(:left, :dummy_record)
   end
 
@@ -158,14 +158,14 @@ describe Syncers::OneWaySyncer do
     helper.stub!(:sync_options).and_return({:direction => :left, :update => true})
     syncer = Syncers::OneWaySyncer.new(helper)
     helper.should_not_receive(:delete_record)
-    helper.should_receive(:update_record).with(:left, :right_record)
+    helper.should_receive(:update_record).with(:left, 'scanner_records', :right_record)
     helper.should_not_receive(:insert_record)
     syncer.sync_difference(:conflict, [:left_record, :right_record])
 
     helper = SyncHelper.new(sync)
     helper.stub!(:sync_options).and_return({:direction => :right, :update => true})
     syncer = Syncers::OneWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:right, :left_record)
+    helper.should_receive(:update_record).with(:right, 'scanner_records', :left_record)
     syncer.sync_difference(:conflict, [:left_record, :right_record])
   end
 end

data/spec/table_sync_spec.rb

@@ -22,7 +22,7 @@ describe TableSync do
     sync.execute_sync_hook(:before_table_sync)
   end
 
-  it "execute_sync_look should execute the given SQL command" do
+  it "execute_sync_hook should execute the given SQL command" do
     config = deep_copy(standard_config)
     config.add_table_options 'scanner_records', :before_table_sync => 'dummy_command'
     session = Session.new config
@@ -34,7 +34,7 @@ describe TableSync do
     sync.execute_sync_hook(:before_table_sync)
   end
 
-  it "execute_sync_look should execute the given Proc" do
+  it "execute_sync_hook should execute the given Proc" do
     config = deep_copy(standard_config)
     received_handler = nil
     config.add_table_options 'scanner_records',
@@ -48,6 +48,52 @@ describe TableSync do
     received_handler.should == :dummy_helper
   end
 
+  it "event_filtered? should return false if there is no event filter" do
+    session = Session.new standard_config
+    sync = TableSync.new(session, 'scanner_records')
+
+    sync.event_filtered?(:left, 'id' => 1).should be_false
+  end
+
+  it "event_filtered? should return false if event filter does not filter sync events" do
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => Object.new
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+
+    sync.event_filtered?(:left, 'id' => 1).should be_false
+  end
+
+  it "event_filtered? should signal filtering (i. e. return true) if the event filter result is false" do
+    filter = Object.new
+    def filter.before_sync(table, key, helper, type, row)
+      false
+    end
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => filter
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.helper = SyncHelper.new(sync)
+    sync.event_filtered?(:left, 'id' => 1).should be_true
+  end
+
+  it "event_filtered? should return false if the event filter result is true" do
+    filter = {}
+    def filter.before_sync(table, key, helper, type, row)
+      self[:args] = [table, key, helper, type, row]
+      true
+    end
+    config = deep_copy(standard_config)
+    config.add_table_options 'scanner_records', :event_filter => filter
+    session = Session.new config
+    sync = TableSync.new(session, 'scanner_records')
+    sync.helper = SyncHelper.new(sync)
+    sync.event_filtered?(:left, 'id' => 1, 'name' => 'bla').should be_false
+
+    # verify correct parameter assignment
+    filter[:args].should == ['scanner_records', {'id' => 1}, sync.helper, :left, {'id' => 1, 'name' => 'bla'}]
+  end
+
   it "run should synchronize the databases" do
     config = deep_copy(standard_config)
     config.options[:committer] = :never_commit
@@ -56,6 +102,12 @@ describe TableSync do
     after_hook_called = false
     config.options[:before_table_sync] = lambda {|helper| before_hook_called = true}
     config.options[:after_table_sync] = lambda { |helper| after_hook_called = true}
+
+    filter = Object.new
+    def filter.before_sync(table, key, helper, type, row)
+      key['id'] != 6
+    end
+    config.options[:event_filter] = filter
     session = Session.new(config)
     begin
       sync = TableSync.new(session, 'scanner_records')
@@ -68,10 +120,14 @@ describe TableSync do
       row['description'].should == 'left_wins'
 
       # verify that the table was synchronized
-      left_records = session.left.select_all("select * from scanner_records order by id")
-      right_records = session.right.select_all("select * from scanner_records order by id")
+      left_records = session.left.select_all("select * from scanner_records where id <> 6 order by id")
+      right_records = session.right.select_all("select * from scanner_records where id <> 6 order by id")
       left_records.should == right_records
 
+      # verify that the filtered out record was not synced
+      session.left.select_one("select * from scanner_records where id = 6").
+        should be_nil
+
       # verify that hooks where called
       before_hook_called.should be_true
       after_hook_called.should be_true

data/spec/two_way_replicator_spec.rb

@@ -68,26 +68,6 @@ describe Replicators::TwoWayReplicator do
     end
   end
 
-  it "options_for_table should return the correct options for the table" do
-    Initializer.configuration.options = {:a => 1, :b => 2}
-    Initializer.configuration.add_table_options 'scanner_records', {:b => 3}
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    replicator = Replicators::TwoWayReplicator.new(helper)
-    options = replicator.options_for_table('scanner_records')
-    options[:a].should == 1
-    options[:b].should == 3
-  end
-
-  it "options_for_table should merge the configured options into the default two way replicator options" do
-    rep_run = ReplicationRun.new(Session.new, TaskSweeper.new(1))
-    helper = ReplicationHelper.new(rep_run)
-    replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.options_for_table('scanner_records').include?(:left_change_handling).should be_true
-    replicator.options_for_table('scanner_records').include?(:right_change_handling).should be_true
-    replicator.options_for_table('scanner_records').include?(:replication_conflict_handling).should be_true
-  end
-
   it "clear_conflicts should update the correct database with the correct action" do
     Initializer.configuration.include_tables 'left_table, right_table'
     session = Session.new
@@ -165,23 +145,23 @@ describe Replicators::TwoWayReplicator do
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_not_receive(:log_replication_outcome)
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => []})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => []})
     replicator.log_replication_outcome :ignore, diff
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
     replicator.log_replication_outcome :left, diff
 
     # should log ignored conflicts correctly
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_receive(:log_replication_outcome).with(diff, 'ignored')
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_conflicts]})
     replicator.log_replication_outcome :ignore, diff
 
     # should log conflicts correctly
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_receive(:log_replication_outcome).with(diff, 'left_won')
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:all_conflicts]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:all_conflicts]})
     replicator.log_replication_outcome :left, diff
   end
 
@@ -200,23 +180,23 @@ describe Replicators::TwoWayReplicator do
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_not_receive(:log_replication_outcome)
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => []})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => []})
     replicator.log_replication_outcome :ignore, diff
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
     replicator.log_replication_outcome :left, diff
 
     # should log changes correctly
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_receive(:log_replication_outcome).with(diff, 'replicated')
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:all_changes]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:all_changes]})
     replicator.log_replication_outcome :right, diff
 
     # should log changes correctly
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
     helper.should_receive(:log_replication_outcome).with(diff, 'ignored')
-    replicator.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
+    helper.stub!(:options_for_table).and_return({:logged_replication_events => [:ignored_changes]})
     replicator.log_replication_outcome :ignore, diff
   end
 
@@ -225,7 +205,7 @@ describe Replicators::TwoWayReplicator do
     rep_run = ReplicationRun.new(session, TaskSweeper.new(1))
     helper = ReplicationHelper.new(rep_run)
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return(
+    helper.stub!(:options_for_table).and_return(
       {
         :left_change_handling => :ignore,
         :right_change_handling => :ignore,
@@ -267,7 +247,7 @@ describe Replicators::TwoWayReplicator do
       lambda_parameters << [rep_helper, diff]
     end
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return(
+    helper.stub!(:options_for_table).and_return(
       {
         :left_change_handling => l,
         :right_change_handling => l,
@@ -317,17 +297,17 @@ describe Replicators::TwoWayReplicator do
     diff.changes[:right] = right_change
 
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return({:replication_conflict_handling => :left_wins})
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :left_wins})
     replicator.should_receive(:clear_conflict).with(:left, diff, 1)
     replicator.replicate_difference diff, 1
 
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return({:replication_conflict_handling => :right_wins})
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :right_wins})
     replicator.should_receive(:clear_conflict).with(:right, diff, 1)
     replicator.replicate_difference diff, 1
 
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return({:replication_conflict_handling => :later_wins})
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :later_wins})
     replicator.should_receive(:clear_conflict).with(:left, diff, 1).twice
     left_change.last_changed_at = 5.seconds.from_now
     right_change.last_changed_at = Time.now
@@ -339,7 +319,7 @@ describe Replicators::TwoWayReplicator do
     replicator.replicate_difference diff, 1
 
     replicator = Replicators::TwoWayReplicator.new(helper)
-    replicator.stub!(:options_for_table).and_return({:replication_conflict_handling => :earlier_wins})
+    helper.stub!(:options_for_table).and_return({:replication_conflict_handling => :earlier_wins})
     replicator.should_receive(:clear_conflict).with(:left, diff, 1).twice
     left_change.last_changed_at = 5.seconds.ago
     right_change.last_changed_at = Time.now
@@ -449,8 +429,8 @@ describe Replicators::TwoWayReplicator do
       }
       replicator.replicate_difference diff, 2
 
-      session.left.select_one("select * from extender_no_record").should == {
-        'id' => '1',
+      session.left.select_record(:table => "extender_no_record").should == {
+        'id' => 1,
         'name' => 'blub'
       }
     ensure
@@ -725,8 +705,8 @@ describe Replicators::TwoWayReplicator do
       }
       replicator.replicate_difference diff, 2
 
-      session.right.select_one("select * from extender_no_record").should == {
-        'id' => '2',
+      session.right.select_record(:table => "extender_no_record").should == {
+        'id' => 2,
         'name' => 'bla'
       }
     ensure

data/spec/two_way_syncer_spec.rb

@@ -198,8 +198,8 @@ describe Syncers::TwoWaySyncer do
       })
 
     syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:left, :dummy_left)
-    helper.should_receive(:delete_record).with(:right, :dummy_right)
+    helper.should_receive(:delete_record).with(:left, 'scanner_records', :dummy_left)
+    helper.should_receive(:delete_record).with(:right, 'scanner_records', :dummy_right)
     syncer.sync_difference(:left, :dummy_left)
     syncer.sync_difference(:right, :dummy_right)
   end
@@ -216,8 +216,8 @@ describe Syncers::TwoWaySyncer do
       })
 
     syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:insert_record).with(:right, :dummy_left)
-    helper.should_receive(:insert_record).with(:left, :dummy_right)
+    helper.should_receive(:insert_record).with(:right, 'scanner_records', :dummy_left)
+    helper.should_receive(:insert_record).with(:left, 'scanner_records', :dummy_right)
     syncer.sync_difference(:left, :dummy_left)
     syncer.sync_difference(:right, :dummy_right)
   end
@@ -234,7 +234,7 @@ describe Syncers::TwoWaySyncer do
       })
 
     syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:left, :dummy_right)
+    helper.should_receive(:update_record).with(:left, 'scanner_records', :dummy_right)
     syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
   end
 
@@ -250,7 +250,7 @@ describe Syncers::TwoWaySyncer do
       })
 
     syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:right, :dummy_left)
+    helper.should_receive(:update_record).with(:right, 'scanner_records', :dummy_left)
     syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
   end
 end

data/spec/type_casting_cursor_spec.rb

@@ -16,9 +16,10 @@ describe TypeCastingCursor do
   
   it "next_row should delegate next? and clear to the original cursor" do
     session = Session.new
-    org_cursor = session.left.select_cursor(:query => "select id from extender_type_check where id = 1")
-    
-    cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
+    cursor = session.left.select_cursor(
+      :query => "select id from extender_type_check where id = 1",
+      :table => "extender_type_check"
+    )
     cursor.next?.should be_true
     row = cursor.next_row
     cursor.next?.should be_false
@@ -27,11 +28,11 @@ describe TypeCastingCursor do
   
   it "next_row should cast rows - including uncommon data types - correctly" do
     session = Session.new
-    org_cursor = session.left.select_cursor(:query => "select id, decimal_test, timestamp, binary_test from extender_type_check where id = 1")
-    cursor = TypeCastingCursor.new session.left, 'extender_type_check', org_cursor
+    row = session.left.select_record(
+      :query => "select id, decimal_test, timestamp, binary_test from extender_type_check where id = 1",
+      :table => "extender_type_check"
+    )
 
-    row = cursor.next_row
-    
     # verify that the row fields have been converted to the correct types
     row['id'].should be_an_instance_of(Fixnum)
     row['timestamp'].should be_an_instance_of(Time)
@@ -45,6 +46,5 @@ describe TypeCastingCursor do
       'timestamp' => Time.local(2007,"nov",10,20,15,1),
       'binary_test' => Marshal.dump(['bla',:dummy,1,2,3])
     }
-    cursor.clear
   end
 end

data/tasks/database.rake

@@ -257,6 +257,12 @@ def create_sample_schema(database, config)
       t.column :name, :string
     end
 
+    connection = ActiveRecord::Base.connection
+    # Neccessary to create tables with dots in ActiveRecord 2.3.5
+    def connection.extract_pg_identifier_from_name(name)
+      return name, nil
+    end
+
     create_table STRANGE_TABLE do |t|
       t.column :first_fk, :integer
       t.column :second_fk, :integer

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: rubyrep
 version: !ruby/object:Gem::Version 
-  version: 1.0.9
+  version: 1.1.0
 platform: ruby
 authors: 
 - Arndt Lehmann
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-14 00:00:00 +09:00
+date: 2009-12-14 00:00:00 +09:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.2.2
+        version: 2.3.5
     version: 
 - !ruby/object:Gem::Dependency 
   name: activerecord
@@ -30,7 +30,7 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 2.2.2
+        version: 2.3.5
     version: 
 - !ruby/object:Gem::Dependency 
   name: hoe