rubyrep 1.0.0

data/spec/two_way_syncer_spec.rb

@@ -0,0 +1,256 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Syncers::TwoWaySyncer do
+  before(:each) do
+    Initializer.configuration = deep_copy(standard_config)
+    Initializer.configuration.options = {:syncer => :two_way}
+  end
+
+  it "should register itself" do
+    Syncers::syncers[:two_way].should == Syncers::TwoWaySyncer
+  end
+
+  it "initialize should store sync_helper" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    syncer.sync_helper.should == helper
+  end
+
+  it "initialize should throw an error if options are invalid" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    base_options = {
+      :syncer => :two_way,
+      :left_record_handling => :ignore,
+      :right_record_handling => :ignore,
+      :sync_conflict_handling => :ignore,
+      :logged_sync_events => []
+    }
+
+    # Verify that correct options don't raise errors.
+    helper.stub!(:sync_options).and_return(base_options)
+    lambda {Syncers::TwoWaySyncer.new(helper)}.should_not raise_error
+
+    # Also lambda options should not raise errors.
+    l = lambda {}
+    helper.stub!(:sync_options).and_return(base_options.merge(
+        {
+          :left_record_handling => l,
+          :right_record_handling => l,
+          :sync_conflict_handling => l
+        })
+    )
+    lambda {Syncers::TwoWaySyncer.new(helper)}.should_not raise_error
+
+    # Invalid options should raise errors
+    invalid_options = [
+      {:left_record_handling => :invalid_left_option},
+      {:right_record_handling => :invalid_right_option},
+      {:sync_conflict_handling => :invalid_conflict_option},
+      {:logged_sync_events => [:invalid_logging_option]}
+    ]
+    invalid_options.each do |options|
+      helper.stub!(:sync_options).and_return(base_options.merge(options))
+      lambda {Syncers::TwoWaySyncer.new(helper)}.should raise_error(ArgumentError)
+    end
+  end
+
+  it "log_sync_outcome should not log if not so configured" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+
+    helper = SyncHelper.new(sync)
+    helper.should_not_receive(:log_sync_outcome)
+    helper.stub!(:sync_options).and_return(
+      {
+        :rep_prefix => 'rr',
+        :left_record_handling => :ignore,
+        :right_record_handling => :ignore,
+        :sync_conflict_handling => :ignore,
+        :logged_sync_events => []
+      })
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    [:left, :right, :conflict].each do |diff_type|
+      syncer.sync_difference(diff_type, :dummy_row)
+    end
+
+    helper = SyncHelper.new(sync)
+    helper.should_not_receive(:log_sync_outcome)
+    helper.stub!(:sync_options).and_return(
+      {
+        :rep_prefix => 'rr',
+        :left_record_handling => :insert,
+        :right_record_handling => :insert,
+        :sync_conflict_handling => :right_wins,
+        :logged_sync_events => [:ignored_changes, :ignored_conflicts]
+      })
+    helper.stub!(:insert_record)
+    helper.stub!(:update_record)
+    syncer.sync_difference :left, :dummy_row
+    syncer.sync_difference :right, :dummy_row
+    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
+  end
+
+  it "log_sync_outcome should log sync actions correctly" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+
+    helper = SyncHelper.new(sync)
+    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'left_record', :insert).ordered
+    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'right_record', :insert).ordered
+    helper.should_receive(:log_sync_outcome).with(:left_dummy_row, 'conflict', :right_wins).ordered
+    helper.stub!(:sync_options).and_return(
+      {
+        :rep_prefix => 'rr',
+        :left_record_handling => :insert,
+        :right_record_handling => :insert,
+        :sync_conflict_handling => :right_wins,
+        :logged_sync_events => [:all_changes, :all_conflicts]
+      })
+    helper.stub!(:insert_record)
+    helper.stub!(:update_record)
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    syncer.sync_difference :left, :dummy_row
+    syncer.sync_difference :right, :dummy_row
+    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
+  end
+
+  it "log_sync_outcome should log ignored syncs correctly" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+
+    helper = SyncHelper.new(sync)
+    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'left_record', :ignore).ordered
+    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'right_record', :ignore).ordered
+    helper.should_receive(:log_sync_outcome).with(:left_dummy_row, 'conflict', :ignore).ordered
+    helper.stub!(:sync_options).and_return(
+      {
+        :rep_prefix => 'rr',
+        :left_record_handling => :ignore,
+        :right_record_handling => :ignore,
+        :sync_conflict_handling => :ignore,
+        :logged_sync_events => [:ignored_changes, :ignored_conflicts]
+      })
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    syncer.sync_difference :left, :dummy_row
+    syncer.sync_difference :right, :dummy_row
+    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
+  end
+
+  it "sync_difference should not do anything if ignore option is given" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => :ignore,
+        :right_record_handling => :ignore,
+        :sync_conflict_handling => :ignore,
+        :logged_sync_events => []
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    helper.should_not_receive(:delete_record)
+    helper.should_not_receive(:update_record)
+    helper.should_not_receive(:insert_record)
+
+    [:left, :right, :conflict].each do |diff_type|
+      syncer.sync_difference(diff_type, :dummy_row)
+    end
+  end
+
+  it "sync_difference should call the provided Proc objects" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+
+    lambda_parameters = []
+    l = lambda do |sync_helper, type, row|
+      lambda_parameters << [sync_helper, type, row]
+    end
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => l,
+        :right_record_handling => l,
+        :sync_conflict_handling => l,
+        :logged_sync_events => [:ignored_conflicts]
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    syncer.sync_difference(:left, :dummy_left)
+    syncer.sync_difference(:right, :dummy_right)
+    syncer.sync_difference(:conflict, [:dummy_left2, :dummy_right2])
+
+    lambda_parameters.should == [
+      [helper, :left, :dummy_left],
+      [helper, :right, :dummy_right],
+      [helper, :conflict, [:dummy_left2, :dummy_right2]]
+    ]
+  end
+
+  it "sync_difference should delete left or right records from source if that option is given" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => :delete,
+        :right_record_handling => :delete,
+        :sync_conflict_handling => :ignore,
+        :logged_sync_events => [:ignored_conflicts]
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    helper.should_receive(:delete_record).with(:left, :dummy_left)
+    helper.should_receive(:delete_record).with(:right, :dummy_right)
+    syncer.sync_difference(:left, :dummy_left)
+    syncer.sync_difference(:right, :dummy_right)
+  end
+
+  it "sync_difference should insert left or right records to target if that option is given" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => :insert,
+        :right_record_handling => :insert,
+        :sync_conflict_handling => :ignore,
+        :logged_sync_events => [:ignored_conflicts]
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    helper.should_receive(:insert_record).with(:right, :dummy_left)
+    helper.should_receive(:insert_record).with(:left, :dummy_right)
+    syncer.sync_difference(:left, :dummy_left)
+    syncer.sync_difference(:right, :dummy_right)
+  end
+
+  it "sync_difference should update the left database if conflict handling is specified with :right_wins" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => :ignore,
+        :right_record_handling => :ignore,
+        :sync_conflict_handling => :right_wins,
+        :logged_sync_events => [:ignored_conflicts]
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    helper.should_receive(:update_record).with(:left, :dummy_right)
+    syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
+  end
+
+  it "sync_difference should update the right database if conflict handling is specified with :left_wins" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return(
+      {
+        :left_record_handling => :ignore,
+        :right_record_handling => :ignore,
+        :sync_conflict_handling => :left_wins,
+        :logged_sync_events => [:ignored_conflicts]
+      })
+
+    syncer = Syncers::TwoWaySyncer.new(helper)
+    helper.should_receive(:update_record).with(:right, :dummy_left)
+    syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
+  end
+end

data/spec/type_casting_cursor_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TypeCastingCursor do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should cache the provided cursor and the retrieved Column objects" do
+    cursor = TypeCastingCursor.new Session.new.left, 'extender_type_check', :dummy_org_cursor
+    cursor.columns['id'].name.should == 'id'
+    cursor.columns['decimal_test'].name.should == 'decimal_test'
+    cursor.org_cursor.should == :dummy_org_cursor
+  end
+  
+  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.next?.should be_true
+    row = cursor.next_row
+    cursor.next?.should be_false
+    cursor.clear
+  end
+  
+  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 = 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)
+    row['decimal_test'].should be_an_instance_of(BigDecimal)
+    row['binary_test'].should be_an_instance_of(String)
+    
+    # verify that the row values were converted correctly
+    row.should == {
+      'id' => 1, 
+      'decimal_test' => BigDecimal.new("1.234"),
+      'timestamp' => Time.local(2007,"nov",10,20,15,1),
+      'binary_test' => Marshal.dump(['bla',:dummy,1,2,3])
+    }
+    cursor.clear
+  end
+end

data/spec/uninstall_runner_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe UninstallRunner do
+  before(:each) do
+  end
+
+  it "should register itself with CommandRunner" do
+    CommandRunner.commands['uninstall'][:command].should == UninstallRunner
+    CommandRunner.commands['uninstall'][:description].should be_an_instance_of(String)
+  end
+
+  it "process_options should make options as nil and teturn status as 1 if command line parameters are unknown" do
+    # also verify that an error message is printed
+    $stderr.should_receive(:puts).any_number_of_times
+    runner = UninstallRunner.new
+    status = runner.process_options ["--nonsense"]
+    runner.options.should == nil
+    status.should == 1
+  end
+
+  it "process_options should make options as nil and return status as 1 if config option is not given" do
+    # also verify that an error message is printed
+    $stderr.should_receive(:puts).any_number_of_times
+    runner = UninstallRunner.new
+    status = runner.process_options []
+    runner.options.should == nil
+    status.should == 1
+  end
+
+  it "process_options should make options as nil and return status as 0 if command line includes '--help'" do
+    # also verify that the help message is printed
+    $stderr.should_receive(:puts)
+    runner = UninstallRunner.new
+    status = runner.process_options ["--help"]
+    runner.options.should == nil
+    status.should == 0
+  end
+
+  it "process_options should set the correct options" do
+    runner = UninstallRunner.new
+    runner.process_options ["-c", "config_path"]
+    runner.options[:config_file].should == 'config_path'
+  end
+
+  it "run should not start an uninstall if the command line is invalid" do
+    $stderr.should_receive(:puts).any_number_of_times
+    UninstallRunner.any_instance_should_not_receive(:execute) {
+      UninstallRunner.run(["--nonsense"])
+    }
+  end
+
+  it "run should start an uninstall if the command line is correct" do
+    UninstallRunner.any_instance_should_receive(:execute) {
+      UninstallRunner.run(["--config=path"])
+    }
+  end
+
+  it "session should create and return the session" do
+    runner = UninstallRunner.new
+    runner.options = {:config_file => "config/test_config.rb"}
+    runner.session.should be_an_instance_of(Session)
+    runner.session.should == runner.session # should only be created one time
+  end
+
+  it "execute should uninstall all rubyrep elements" do
+    config = deep_copy(standard_config)
+    config.options[:rep_prefix] = 'rx'
+    session = Session.new(config)
+    initializer = ReplicationInitializer.new(session)
+
+    initializer.ensure_infrastructure
+    initializer.create_trigger :left, 'scanner_records'
+
+    runner = UninstallRunner.new
+    runner.stub!(:session).and_return(session)
+
+    runner.execute
+
+    initializer.trigger_exists?(:left, 'scanner_records').should be_false
+    initializer.change_log_exists?(:left).should be_false
+    session.right.tables.include?('rx_running_flags').should be_false
+    initializer.event_log_exists?.should be_false
+  end
+end