andyjeffries-rubyrep 1.2.1

data/spec/sync_runner_spec.rb

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe SyncRunner do
+  before(:each) do
+  end
+
+  it "should register itself with CommandRunner" do
+    CommandRunner.commands['sync'][:command].should == SyncRunner
+    CommandRunner.commands['sync'][:description].should be_an_instance_of(String)
+  end
+
+  it "prepare_table_pairs should sort the tables" do
+    session = Session.new standard_config
+    session.should_receive(:sort_table_pairs).
+      with(:dummy_table_pairs).
+      and_return(:sorted_dummy_table_pairs)
+
+    sync_runner = SyncRunner.new
+    sync_runner.stub!(:session).and_return(session)
+
+    sync_runner.prepare_table_pairs(:dummy_table_pairs).should == :sorted_dummy_table_pairs
+  end
+
+  it "execute should sync the specified tables" do
+    org_stdout = $stdout
+    session = nil
+
+    # This is necessary to avoid the cached RubyRep configurations from getting
+    # overwritten by the sync run
+    old_config, Initializer.configuration = Initializer.configuration, Configuration.new
+
+    session = Session.new(standard_config)
+    session.left.begin_db_transaction
+    session.right.begin_db_transaction
+
+    $stdout = StringIO.new
+    begin
+      sync_runner = SyncRunner.new
+      sync_runner.options = {
+        :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
+        :table_specs => ["scanner_records"]
+      }
+
+      sync_runner.execute
+
+      $stdout.string.should =~
+        /scanner_records .* 5\n/
+
+      left_records = session.left.connection.select_all("select * from scanner_records order by id")
+      right_records = session.right.connection.select_all("select * from scanner_records order by id")
+      left_records.should == right_records
+    ensure
+      $stdout = org_stdout
+      Initializer.configuration = old_config if old_config
+      if session
+        session.left.rollback_db_transaction
+        session.right.rollback_db_transaction
+      end
+    end
+  end
+
+  it "create_processor should create the TableSync instance" do
+    TableSync.should_receive(:new).
+      with(:dummy_session, "left_table", "right_table").
+      and_return(:dummy_table_sync)
+    sync_runner = SyncRunner.new
+    sync_runner.should_receive(:session).and_return(:dummy_session)
+    sync_runner.create_processor("left_table", "right_table").
+      should == :dummy_table_sync
+  end
+
+  it "summary_description should return a description" do
+    SyncRunner.new.summary_description.should be_an_instance_of(String)
+  end
+
+end

data/spec/syncers_spec.rb

@@ -0,0 +1,171 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Syncers do
+  before(:each) do
+    @old_syncers = Syncers.syncers
+  end
+
+  after(:each) do
+    Syncers.instance_variable_set :@syncers, @old_syncers
+  end
+
+  it "syncers should return empty hash if nil" do
+    Syncers.instance_variable_set :@syncers, nil
+    Syncers.syncers.should == {}
+  end
+
+  it "syncers should return the registered syncers" do
+    Syncers.instance_variable_set :@syncers, :dummy_data
+    Syncers.syncers.should == :dummy_data
+  end
+
+  it "configured_syncer should return the correct syncer as per :syncer option, if both :syncer and :replicator is configured" do
+    options = {
+      :syncer => :two_way,
+      :replicator => :key2
+    }
+    Syncers.configured_syncer(options).should == Syncers::TwoWaySyncer
+  end
+
+  it "configured_syncer should return the correct syncer as per :replicator option if no :syncer option is provided" do
+    options = {:replicator => :two_way}
+    Syncers.configured_syncer(options).should == Syncers::TwoWaySyncer
+  end
+
+  it "register should register the provided commiter" do
+    Syncers.instance_variable_set :@syncers, nil
+    Syncers.register :a_key => :a
+    Syncers.register :b_key => :b
+    Syncers.syncers[:a_key].should == :a
+    Syncers.syncers[:b_key].should == :b
+  end
+end
+
+describe Syncers::OneWaySyncer do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "should register itself" do
+    Syncers::syncers[:one_way].should == Syncers::OneWaySyncer
+  end
+
+  it "initialize should store sync_helper" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    syncer = Syncers::OneWaySyncer.new(helper)
+    syncer.sync_helper.should == helper
+  end
+
+  it "initialize should calculate course source, target and source_record_index" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+
+    # verify correct behaviour if syncing to the left
+    helper.stub!(:sync_options).and_return({:direction => :left})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    syncer.source.should == :right
+    syncer.target.should == :left
+    syncer.source_record_index.should == 1
+
+    # verify correct behaviour if syncing to the right
+    helper.stub!(:sync_options).and_return({:direction => :right})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    syncer.source.should == :left
+    syncer.target.should == :right
+    syncer.source_record_index.should == 0
+  end
+
+  it "default_option should return the correct default options" do
+    Syncers::OneWaySyncer.default_options.should == {
+      :direction => :right,
+      :delete => false, :update => true, :insert => true
+    }
+  end
+
+  it "sync_difference should only delete if :delete option is given" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return({:direction => :left})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    helper.should_not_receive(:delete_record)
+    helper.should_not_receive(:update_record)
+    helper.should_not_receive(:insert_record)
+    syncer.sync_difference(:left, :dummy_record)
+  end
+
+  it "sync_difference should delete in the right database" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    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, 'scanner_records', :dummy_record)
+    helper.should_not_receive(:update_record)
+    helper.should_not_receive(:insert_record)
+    syncer.sync_difference(:left, :dummy_record)
+
+    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, 'scanner_records', :dummy_record)
+    syncer.sync_difference(:right, :dummy_record)
+  end
+
+  it "sync_difference should not insert if :insert option is not true" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return({:direction => :left, :insert => false})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    helper.should_not_receive(:delete_record)
+    helper.should_not_receive(:update_record)
+    helper.should_not_receive(:insert_record)
+    syncer.sync_difference(:right, :dummy_record)
+  end
+
+  it "sync_difference should insert in the right database" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return({:direction => :left, :insert => true})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    helper.should_not_receive(:delete_record)
+    helper.should_not_receive(:update_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, 'scanner_records', :dummy_record)
+    syncer.sync_difference(:left, :dummy_record)
+  end
+
+  it "sync_difference should not update if :update option is not true" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    helper.stub!(:sync_options).and_return({:direction => :left, :update => false})
+    syncer = Syncers::OneWaySyncer.new(helper)
+    helper.should_not_receive(:delete_record)
+    helper.should_not_receive(:update_record)
+    helper.should_not_receive(:insert_record)
+    syncer.sync_difference(:conflict, :dummy_records)
+  end
+
+  it "sync_difference should update the right values in the right database" do
+    sync = TableSync.new(Session.new, 'scanner_records')
+    helper = SyncHelper.new(sync)
+    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, '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, 'scanner_records', :left_record)
+    syncer.sync_difference(:conflict, [:left_record, :right_record])
+  end
+end

data/spec/table_scan_helper_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TableScanHelper do
+  before(:each) do
+    @scan = Object.new
+    @scan.extend TableScanHelper
+  end
+
+  it "rank_rows should calculate the correct rank of rows based on their primary keys" do
+    @scan.stub!(:primary_key_names).and_return(['first_id', 'second_id'])
+    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 1}).should == 0
+    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 2}).should == -1
+    @scan.rank_rows({'first_id' => 2, 'second_id' => 1}, {'first_id' => 1, 'second_id' => 1}).should == 1
+
+    # should rank strings according to database logic ('a' < 'A')
+    # instead of the Ruby logic (which is the other way round)
+    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'B', 'second_id' => 1}).should == -1
+    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'A', 'second_id' => 1}).should == -1
+    @scan.rank_rows({'first_id' => 'a', 'second_id' => 1}, {'first_id' => 'a', 'second_id' => 1}).should == 0
+
+    lambda {@scan.rank_rows(nil,nil)}.should raise_error(RuntimeError, 'At least one of left_row and right_row must not be nil!')
+    @scan.rank_rows(nil, {'first_id' => 1, 'second_id' => 1}).should == 1
+    @scan.rank_rows({'first_id' => 1, 'second_id' => 1}, nil).should == -1
+  end
+
+  it "table_scan_class should return TableScan for non-proxied sessions" do
+    TableScanHelper.scan_class(Session.new(standard_config)).should == DirectTableScan
+  end
+
+  it "table_scan_class should return ProxiedTableScan for proxied sessions" do
+    ensure_proxy
+    TableScanHelper.scan_class(Session.new(proxied_config)).should == ProxiedTableScan
+  end
+end

data/spec/table_scan_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TableScan do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "initialize should raise exception if table doesn't have primary keys" do
+    session = Session.new
+    lambda {TableScan.new session, 'extender_without_key'} \
+      .should raise_error(RuntimeError, /.*extender_without_key.*primary key/)
+  end
+
+  it "initialize should cache the primary keys of the given table" do
+    session = Session.new
+    scann = TableScan.new session, 'scanner_records'
+    scann.primary_key_names.should == ['id']
+  end
+
+  it "initialize should use the name of the left table as overwritable default for right table" do
+    session = Session.new
+    TableScan.new(session, 'scanner_records').right_table.should == 'scanner_records'
+    TableScan.new(session, 'scanner_records', 'dummy').right_table.should == 'dummy'
+  end
+
+  it "progress_printer= should store the progress printer class" do
+    session = Session.new
+    TableScan.new(session, 'scanner_records').progress_printer = :dummy_printer_class
+  end
+
+  it "update_progres should create the progress printer and report the progress" do
+    session = Session.new
+    scan = TableScan.new(session, 'extender_one_record', 'extender_no_record')
+
+    progress_printer_class = mock("progress printer class")
+    progress_printer = mock("progress printer")
+    progress_printer_class.should_receive(:new).
+      with(1, scan.session, 'extender_one_record', 'extender_no_record').
+      and_return(progress_printer)
+    progress_printer.should_receive(:step).with(2)
+    progress_printer.should_receive(:step).with(3)
+
+    scan.progress_printer = progress_printer_class
+    scan.update_progress 2
+    scan.update_progress 3
+  end
+end

data/spec/table_sorter_spec.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TableSorter do
+  before(:each) do
+  end
+
+  it "sort should order the tables correctly" do
+    tables = [
+      'scanner_records',
+      'referencing_table',
+      'referenced_table',
+      'scanner_text_key',
+    ]
+
+    sorter = TableSorter.new Session.new(standard_config), tables
+    sorted_tables = sorter.sort
+
+    # make sure it contains the original tables
+    sorted_tables.sort.should == tables.sort
+
+    # make sure the referenced table comes before the referencing table
+    sorted_tables.grep(/referenc/).should == ['referenced_table', 'referencing_table']
+
+    # verify that we are using TSort#tsort to get that result
+    sorter.should_not_receive(:tsort)
+    sorter.sort
+  end
+end

data/spec/table_spec_resolver_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe TableSpecResolver do
+  before(:each) do
+    Initializer.configuration = standard_config
+    @session = Session.new
+    @resolver = TableSpecResolver.new @session
+  end
+
+  it "initialize should store the session and cache the tables of the session" do
+    @resolver.session.should == @session
+  end
+
+  it "tables should return the tables of the specified database" do
+    @resolver.tables(:left).should == @session.left.tables
+    @resolver.tables(:right).should == @session.right.tables
+  end
+  
+  it "resolve should resolve direct table names correctly" do
+    @resolver.resolve(['scanner_records', 'referenced_table']).should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+      {:left => 'referenced_table', :right => 'referenced_table'}
+    ]
+  end
+  
+  it "resolve should resolve table name pairs correctly" do
+    @resolver.resolve(['left_table , right_table']).should == [
+      {:left => 'left_table', :right => 'right_table'}
+    ]
+  end
+  
+  it "resolve should complain about non-existing tables" do
+    lambda {@resolver.resolve(['dummy, scanner_records'])}.
+      should raise_error(/non-existing.*dummy/)
+    lambda {@resolver.resolve(['left_table, left_table'])}.
+      should raise_error(/non-existing.*left_table/)
+    lambda {@resolver.resolve(['left_table'])}.
+      should raise_error(/non-existing.*left_table/)
+  end
+
+  it "resolve should not complain about regexp specified tables not existing in right database" do
+    @resolver.resolve([/^scanner_records$/, /left_table/]).
+      should == [{:left => 'scanner_records', :right => 'scanner_records'}]
+  end
+
+  it "resolve should not check for non-existing tables if that is disabled" do
+    lambda {@resolver.resolve(['dummy, scanner_records'], [], false)}.
+      should_not raise_error
+  end
+
+  it "resolve should resolve string in form of regular expression correctly" do
+    @resolver.resolve(['/SCANNER_RECORDS|scanner_text_key/']).sort { |a,b|
+      a[:left] <=> b[:left]
+    }.should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+      {:left => 'scanner_text_key', :right => 'scanner_text_key'}
+    ]
+  end
+
+  it "resolve should resolve regular expressions correctly" do
+    @resolver.resolve([/SCANNER_RECORDS|scanner_text_key/]).sort { |a,b|
+      a[:left] <=> b[:left]
+    }.should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+      {:left => 'scanner_text_key', :right => 'scanner_text_key'}
+    ]
+  end
+
+  it "resolve should should not return the same table multiple times" do
+    @resolver.resolve([
+        'scanner_records',
+        'scanner_records',
+        'scanner_records, bla',
+        '/scanner_records/'
+      ]
+    ).should == [
+      {:left => 'scanner_records', :right => 'scanner_records'}
+    ]
+  end
+
+  it "resolve should not return tables that are excluded" do
+    @resolver.resolve(
+      [/SCANNER_RECORDS|scanner_text_key/],
+      [/scanner_text/]
+    ).should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+    ]
+  end
+
+  it "non_existing_tables should return an empty hash if all tables exist" do
+    table_pairs = [{:left => 'scanner_records', :right => 'referenced_table'}]
+    @resolver.non_existing_tables(table_pairs).should == {}
+  end
+
+  it "non_existing_tables should return a hash of non-existing tables" do
+    table_pairs = [{:left => 'scanner_records', :right => 'bla'}]
+    @resolver.non_existing_tables(table_pairs).should == {:right => ['bla']}
+
+    table_pairs = [
+      {:left => 'blub', :right => 'bla'},
+      {:left => 'scanner_records', :right => 'xyz'}
+      ]
+    @resolver.non_existing_tables(table_pairs).should == {
+      :left => ['blub'],
+      :right => ['bla', 'xyz']
+    }
+  end
+
+end