andyjeffries-rubyrep 1.2.1

data/spec/replicators_spec.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Replicators do
+  before(:each) do
+    @old_replicators = Replicators.replicators
+  end
+
+  after(:each) do
+    Replicators.instance_variable_set :@replicators, @old_replicators
+  end
+
+  it "replicators should return empty hash if nil" do
+    Replicators.instance_variable_set :@replicators, nil
+    Replicators.replicators.should == {}
+  end
+
+  it "replicators should return the registered replicators" do
+    Replicators.instance_variable_set :@replicators, :dummy_data
+    Replicators.replicators.should == :dummy_data
+  end
+
+  it "configured_replicator should return the correct replicator" do
+    options = {:replicator => :two_way}
+    Replicators.configured_replicator(options).should == Replicators::TwoWayReplicator
+  end
+  
+  it "register should register the provided replicator" do
+    Replicators.instance_variable_set :@replicators, nil
+    Replicators.register :a_key => :a
+    Replicators.register :b_key => :b
+    Replicators.replicators[:a_key].should == :a
+    Replicators.replicators[:b_key].should == :b
+  end
+end

data/spec/rubyrep_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+# Time to add your specs!
+# http://rspec.rubyforge.org/
+describe "Place your specs here" do
+  
+  
+end

data/spec/scan_detail_reporter_spec.rb

@@ -0,0 +1,119 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ScanReportPrinters::ScanDetailReporter do
+  before(:each) do
+    Initializer.configuration = standard_config
+    $stdout.should_receive(:puts).any_number_of_times
+  end
+
+  it "should register itself with ScanRunner" do
+    RR::ScanReportPrinters.printers.any? do |printer|
+      printer[:printer_class] == ScanReportPrinters::ScanDetailReporter
+    end.should be_true
+  end
+  
+  it "initialize should store the provided session" do
+    ScanReportPrinters::ScanDetailReporter.new(:dummy_session, nil).session.should == :dummy_session
+  end
+  
+  it "scan should print the summary and the dump of the differences if mode = 'full'" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      reporter = ScanReportPrinters::ScanDetailReporter.new(nil, 'full')
+      
+      # set some existing scan result to ensure it gets reset before the next run
+      reporter.scan_result = {:conflict => 0, :left => 0, :right => 1}
+      
+      reporter.scan('left_table', 'right_table') do 
+        reporter.report_difference :conflict, :dummy_row
+        reporter.report_difference :left, :dummy_row
+        reporter.report_difference :right, :dummy_row
+      end
+      
+      # verify summary
+      $stdout.string.should =~ /left_table \/ right_table [\.\s]*3\n/
+
+      # verify dump
+      io = StringIO.new($stdout.string.gsub(/^.*left_table.*$/, ''))
+      dump_objects = []
+      YAML.load_documents(io) do |yl|
+        dump_objects << yl
+      end
+      dump_objects.should == [
+        {:conflict=>:dummy_row},
+        {:left=>:dummy_row},
+        {:right=>:dummy_row}
+      ]
+    ensure 
+      $stdout = org_stdout
+    end
+  end
+
+  it "scan should print the summary and the keys of the differences if mode = 'keys'" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      session = Session.new
+      reporter = ScanReportPrinters::ScanDetailReporter.new(session, 'keys')
+
+      # set some existing scan result to ensure it gets reset before the next run
+      reporter.scan_result = {:conflict => 0, :left => 0, :right => 1}
+
+      reporter.scan('scanner_records', 'scanner_records') do
+        reporter.report_difference :conflict, [{'id' => 1, 'name' => 'bla'}, {'id' => 1, 'name' => 'blub'}]
+        reporter.report_difference :left, {'id' => 2, 'name' => 'bla'}
+        reporter.report_difference :right, {'id' => 3, 'name' => 'blub'}
+      end
+
+      io = StringIO.new($stdout.string.gsub(/^.*scanner_records.*$/, ''))
+      dump_objects = []
+      YAML.load_documents(io) do |yl|
+        dump_objects << yl
+      end
+      dump_objects.should == [
+        {:conflict=>{"id"=>1}},
+        {:left=>{"id"=>2}},
+        {:right=>{"id"=>3}}
+      ]
+    ensure
+      $stdout = org_stdout
+    end
+  end
+
+  it "scan should print the summary and the differing columns of the differences if mode = 'diff'" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      session = Session.new
+      reporter = ScanReportPrinters::ScanDetailReporter.new(session, 'diff')
+
+      # set some existing scan result to ensure it gets reset before the next run
+      reporter.scan_result = {:conflict => 0, :left => 0, :right => 1}
+
+      reporter.scan('scanner_records', 'scanner_records') do
+        reporter.report_difference :conflict, [
+          {'id' => 1, 'name' => 'bla', 'age' => 20},
+          {'id' => 1, 'name' => 'blub', 'age' => 20}
+        ]
+        reporter.report_difference :left, {'id' => 2, 'name' => 'bla'}
+        reporter.report_difference :right, {'id' => 3, 'name' => 'blub'}
+      end
+
+      io = StringIO.new($stdout.string.gsub(/^.*scanner_records.*$/, ''))
+      dump_objects = []
+      YAML.load_documents(io) do |yl|
+        dump_objects << yl
+      end
+      dump_objects.should == [
+        {:conflict=>[{'id' => 1, 'name' => 'bla'}, {'id' => 1, 'name' => 'blub'}]},
+        {:left=>{"name"=>"bla", "id"=>2}},
+        {:right=>{"name"=>"blub", "id"=>3}}
+      ]
+    ensure
+      $stdout = org_stdout
+    end
+  end
+end

data/spec/scan_progress_printers_spec.rb

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ScanProgressPrinters do
+  before(:each) do
+  end
+
+  it "report_printers should an empty hash if there are no registered printers" do
+    org_printers = ScanProgressPrinters.printers
+    begin
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, nil }
+      ScanProgressPrinters.printers.should == {}
+    ensure
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, org_printers }
+    end
+  end
+  
+  it "register_printer should store the provided printers, printers should return them" do
+    org_printers = ScanProgressPrinters.printers
+    begin
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, nil }
+      ScanProgressPrinters.register :dummy_printer_id, :dummy_printer_class, "-d", "--dummy"
+      ScanProgressPrinters.register :another_printer_id, :another_printer_class, "-t"
+      ScanProgressPrinters.printers.should == {
+        :dummy_printer_id => {
+          :printer_class => :dummy_printer_class,
+          :opts => ["-d", "--dummy"]
+        },
+        :another_printer_id => {
+          :printer_class => :another_printer_class,
+          :opts => ["-t"]
+        }
+      }
+    ensure
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, org_printers }
+    end
+  end
+
+  it "on_printer_selection should create and yield the correct printer" do
+    org_printers = ScanProgressPrinters.printers
+    begin
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, nil }
+
+      # register a printer which will not be selected in the command line options
+      printer_x_class = mock("printer_x")
+      printer_x_class.should_not_receive :arg=
+      ScanProgressPrinters.register :printer_x_id, printer_x_class, "-x", "--printer_x"
+
+      # register a printer that will be selected in the command line options
+      printer_y_class = mock("printer_y")
+      printer_y_class.should_receive(:arg=).with("dummy_arg")
+
+      ScanProgressPrinters.register :printer_y_id, printer_y_class, "-y", "--printer_y[=arg]", "description"
+
+      selected_printer = nil
+      parser = OptionParser.new
+      ScanProgressPrinters.on_printer_selection(parser) do |printer|
+        selected_printer = printer
+      end
+      parser.parse!(["--printer_y=dummy_arg"])
+
+      selected_printer.should == printer_y_class
+    ensure
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, org_printers }
+    end
+  end
+end

data/spec/scan_report_printers_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ScanReportPrinters do
+  before(:each) do
+  end
+
+  it "report_printers should an empty array if there are no registered printers" do
+    org_printers = ScanReportPrinters.printers
+    begin
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, nil }
+      ScanReportPrinters.printers.should == []
+    ensure
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, org_printers }
+    end
+  end
+  
+  it "register_printer should store the provided printers, report_printer should return them" do
+    org_printers = ScanReportPrinters.printers
+    begin
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, nil }
+      ScanReportPrinters.register :dummy_printer_class, "-d", "--dummy"
+      ScanReportPrinters.register :another_printer_class, "-t"
+      ScanReportPrinters.printers.should == [
+        { :printer_class => :dummy_printer_class,
+          :opts => ["-d", "--dummy"]
+        },
+        { :printer_class => :another_printer_class,
+          :opts => ["-t"]
+        }
+      ]
+    ensure
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, org_printers }
+    end
+  end
+
+  it "on_printer_selection should create and yield the printer class and option argument" do
+    org_printers = ScanReportPrinters.printers
+    begin
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, nil }
+
+      # register a printer class which will not be selected in the command line options
+      printer_x = mock("printer_x")
+      ScanReportPrinters.register printer_x, "-x", "--printer_x"
+
+      # register a printer class that will be selected in the command line options
+      printer_y = mock("printer_y")
+
+      ScanReportPrinters.register printer_y, "-y", "--printer_y[=arg]", "description"
+
+      selected_printer_class = nil
+      selected_arg = nil
+      parser = OptionParser.new
+      ScanReportPrinters.on_printer_selection(parser) do |printer_class, arg|
+        selected_printer_class = printer_class
+        selected_arg = arg
+      end
+      parser.parse!(["--printer_y=dummy_arg"])
+
+      selected_printer_class.should == printer_y
+      selected_arg.should == 'dummy_arg'
+    ensure
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, org_printers }
+    end
+  end
+end

data/spec/scan_runner_spec.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ScanRunner do
+  before(:each) do
+  end
+
+  it "should register itself with CommandRunner" do
+    CommandRunner.commands['scan'][:command].should == ScanRunner
+    CommandRunner.commands['scan'][:description].should be_an_instance_of(String)
+  end
+
+  it "execute should scan the specified tables" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      Initializer.configuration = Configuration.new
+      scan_runner = ScanRunner.new
+      scan_runner.options = {
+        :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
+        :table_specs => ["scanner_records", "extender_one_record"]
+      }
+
+      scan_runner.execute
+
+      $stdout.string.should =~ /scanner_records.* 5\n/
+      $stdout.string.should =~ /extender_one_record.* 0\n/
+    ensure
+      $stdout = org_stdout
+    end
+  end
+
+  it "create_processor should create the correct table scanner" do
+    scan_runner = ScanRunner.new
+    dummy_scan_class = mock("scan class")
+    dummy_scan_class.should_receive(:new).
+      with(:dummy_session, "left_table", "right_table").
+      and_return(:dummy_table_scanner)
+    TableScanHelper.should_receive(:scan_class).with(:dummy_session).
+      and_return(dummy_scan_class)
+    scan_runner.should_receive(:session).any_number_of_times.and_return(:dummy_session)
+    scan_runner.create_processor("left_table", "right_table").
+      should == :dummy_table_scanner
+  end
+
+  it "summary_description should return a description" do
+    ScanRunner.new.summary_description.should be_an_instance_of(String)
+  end
+end

data/spec/scan_summary_reporter_spec.rb

@@ -0,0 +1,61 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ScanReportPrinters::ScanSummaryReporter do
+  before(:each) do
+    $stdout.should_receive(:puts).any_number_of_times
+  end
+
+  it "should register itself with ScanRunner" do
+    RR::ScanReportPrinters.printers.any? do |printer|
+      printer[:printer_class] == ScanReportPrinters::ScanSummaryReporter
+    end.should be_true
+  end
+  
+  it "initialize should detect if the detailed number of differnces should be counted" do
+    ScanReportPrinters::ScanSummaryReporter.new(nil, nil).only_totals.should be_true
+    ScanReportPrinters::ScanSummaryReporter.new(nil, "bla").only_totals.should be_true
+    ScanReportPrinters::ScanSummaryReporter.new(nil, "detailed").only_totals.should be_false
+  end
+  
+  it "scan should count differences correctly in totals mode" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      reporter = ScanReportPrinters::ScanSummaryReporter.new(nil, nil)
+      
+      # set some existing scan result to ensure it gets reset before the next run
+      reporter.scan_result = {:conflict => 0, :left => 0, :right => 1}
+      
+      reporter.scan('left_table', 'right_table') do 
+        reporter.report_difference :conflict, :dummy_row
+        reporter.report_difference :left, :dummy_row
+        reporter.report_difference :right, :dummy_row
+      end
+      $stdout.string.should =~ /left_table \/ right_table [\.\s]*3\n/
+    ensure 
+      $stdout = org_stdout
+    end
+  end
+
+  it "scan should count differences correctly in detailed mode" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      reporter = ScanReportPrinters::ScanSummaryReporter.new(nil, "detailed")
+      
+      reporter.scan('left_table', 'left_table') do
+        reporter.report_difference :conflict, :dummy_row
+        reporter.report_difference :left, :dummy_row
+        reporter.report_difference :left, :dummy_row
+        reporter.report_difference :right, :dummy_row
+        reporter.report_difference :right, :dummy_row
+        reporter.report_difference :right, :dummy_row
+      end
+      $stdout.string.should =~ /left_table\s+1\s+2\s+3\n/
+    ensure 
+      $stdout = org_stdout
+    end
+  end
+end

data/spec/session_spec.rb

@@ -0,0 +1,253 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+require 'yaml'
+
+include RR
+
+describe Session do # database connection caching is disabled
+  before(:each) do
+    Initializer.configuration = standard_config
+    @@old_cache_status = ConnectionExtenders.use_db_connection_cache(false)
+  end
+  
+  after(:each) do
+    ConnectionExtenders.use_db_connection_cache(@@old_cache_status)
+  end
+  
+  it "initialize should keep a reference of the Configuration object" do
+    mock_active_record :twice
+    
+    session = Session.new(Initializer.configuration)
+    session.configuration.should == Initializer.configuration
+  end
+  
+  it "initialize should establish the database connections" do
+    mock_active_record :twice
+    
+    session = Session.new
+  end
+    
+  it "'left=' should store a Connection object and 'left' should return it" do
+    mock_active_record :twice
+    
+    session = Session.new
+    
+    session.left = :dummy
+    session.left.should == :dummy
+  end
+
+  it "'right=' should store a Connection object and 'right' should return it" do
+    mock_active_record :twice
+    
+    session = Session.new
+    
+    session.right = :dummy
+    session.right.should == :dummy
+  end
+
+  it "initialize shouldn't create the same database connection twice" do
+    mock_active_record :once
+
+    Initializer.configuration = deep_copy(Initializer.configuration)
+    Initializer.configuration.right = Initializer.configuration.left.clone
+    
+    session = Session.new
+  end
+end
+
+describe Session do   # here database connection caching is _not_ disabled
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  after(:each) do
+  end
+
+  it "initialize should create (fake) proxy connections as per configuration" do
+    dummy_proxy = Object.new
+    dummy_connection = mock("dummy connection")
+    dummy_connection.stub!(:tables).and_return([])
+    dummy_connection.stub!(:manual_primary_keys=)
+    dummy_connection.stub!(:select_one).and_return({'x' => '2'})
+    dummy_proxy.should_receive(:create_session).and_return(dummy_connection)
+    DRbObject.should_receive(:new).with(nil,"druby://localhost:9876").and_return(dummy_proxy)
+
+    session = Session.new proxied_config
+
+    session.proxies[:left].should == dummy_proxy
+    session.proxies[:right].should be_an_instance_of(DatabaseProxy)
+
+    session.left.should == dummy_connection
+    session.right.should be_an_instance_of(ProxyConnection)
+  end
+
+  it "initialize should assign manual primary keys to the proxy connections" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key, extender_without_key", :primary_key_names => ['id']
+    session = Session.new config
+    session.left.manual_primary_keys.should == {'table_with_manual_key'=>['id']}
+    session.right.manual_primary_keys.should == {'extender_without_key'=>['id']}
+  end
+
+  it "refresh should reestablish the database connections if not active anymore" do
+    session = Session.new
+    session.right.destroy
+    session.right.connection.should_not be_active
+    lambda {session.right.select_one("select 1+1 as x")}.should raise_error
+    session.refresh
+    session.right.connection.should be_active
+    session.right.select_one("select 1+1 as x")['x'].to_i.should == 2
+  end
+
+  it "refresh should raise error even if database connect fails silently" do
+    session = Session.new
+    session.right.destroy
+    session.right.connection.should_not be_active
+    session.should_receive(:connect_database)
+    lambda {session.refresh}.should raise_error(/no connection to.*right.*database/)
+  end
+
+  it "refresh should work with proxied database connections" do
+    ensure_proxy
+    session = Session.new(proxied_config)
+    session.right.destroy
+    session.right.connection.should_not be_active
+    lambda {session.right.select_one("select 1+1 as x")}.should raise_error
+    session.refresh
+    session.right.connection.should be_active
+    session.right.select_one("select 1+1 as x")['x'].to_i.should == 2
+  end
+
+  it "disconnect_databases should disconnect both databases" do
+    session = Session.new(standard_config)
+    session.left.connection.should be_active
+    old_right_connection = session.right.connection
+    old_right_connection.should be_active
+    session.disconnect_databases
+    session.left.should be_nil
+    session.right.should be_nil
+    old_right_connection.should_not be_active
+  end
+
+  it "refresh should not do anyting if the connection is still active" do
+    session = Session.new
+    old_connection_id = session.right.connection.object_id
+    session.refresh
+    session.right.connection.object_id.should == old_connection_id
+  end
+
+  it "refresh should replace active connections if forced is true" do
+    session = Session.new
+    old_connection_id = session.right.connection.object_id
+    session.refresh :forced => true
+    session.right.connection.object_id.should_not == old_connection_id
+  end
+
+  it "manual_primary_keys should return the specified manual primary keys" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key, extender_without_key", :key => ['id']
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {'table_with_manual_key'=>['id']}
+    session.manual_primary_keys(:right).should == {'extender_without_key'=>['id']}
+  end
+
+  it "manual_primary_keys should accept keys that are not packed into an array" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "table_with_manual_key", :key => 'id'
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {'table_with_manual_key'=>['id']}
+  end
+
+  it "manual_primary_keys should follow the :auto_key_limit option" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "scanner_records"
+    config.include_tables "extender_without_key"
+    config.include_tables "table_with_manual_key", :key => 'id'
+
+    config.options[:auto_key_limit] = 2
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {
+      'table_with_manual_key' => ['id'],
+      'extender_without_key' => ['first_id', 'second_id']
+    }
+    session.left.primary_key_names('extender_without_key').should == ['first_id', 'second_id']
+
+    config.options[:auto_key_limit] = 1
+    session = Session.new config
+    session.manual_primary_keys(:left).should == {
+      'table_with_manual_key' => ['id']
+    }
+  end
+
+  it "corresponding_table should return the correct corresponding table" do
+    config = deep_copy(standard_config)
+    config.included_table_specs.clear
+    config.include_tables "/scanner/"
+    config.include_tables "table_with_manual_key, extender_without_key"
+    session = Session.new config
+    
+    session.corresponding_table(:left, 'scanner_records').should == 'scanner_records'
+    session.corresponding_table(:right, 'scanner_records').should == 'scanner_records'
+    session.corresponding_table(:left, 'table_with_manual_key').should == 'extender_without_key'
+    session.corresponding_table(:right, 'extender_without_key').should == 'table_with_manual_key'
+  end
+
+  it "corresponding_table should return the given table if no corresponding table can be found" do
+    session = Session.new
+    session.corresponding_table(:left, 'not_existing_table').should == 'not_existing_table'
+  end
+
+  it "configured_table_pairs should return the table pairs as per included_table_specs parameter" do
+    session = Session.new
+    session.configured_table_pairs(['scanner_records']).should == [
+      {:left => 'scanner_records', :right => 'scanner_records'},
+    ]
+  end
+
+  it "configured_table_pairs should return the table pairs as per configuration if included_table_specs paramter is an empty array" do
+    session = Session.new
+    session.configured_table_pairs([]).should == [
+      {:left => 'scanner_left_records_only', :right => 'scanner_left_records_only'},
+      {:left => 'table_with_manual_key', :right => 'table_with_manual_key'}
+    ]
+  end
+
+  def convert_table_array_to_table_pair_array(tables)
+    tables.map {|table| {:left => table, :right => table}}
+  end
+
+  it "sort_table_pairs should sort the tables correctly" do
+    table_pairs = convert_table_array_to_table_pair_array([
+        'scanner_records',
+        'referencing_table',
+        'referenced_table',
+        'scanner_text_key',
+      ])
+    sorted_table_pairs = Session.new.sort_table_pairs(table_pairs)
+
+    # ensure result holds the original table pairs
+    p = Proc.new {|l, r| l[:left] <=> r[:left]}
+    sorted_table_pairs.sort(&p).should == table_pairs.sort(&p)
+
+    # make sure the referenced table comes before the referencing table
+    sorted_table_pairs.map {|table_pair| table_pair[:left]}.grep(/referenc/).
+      should == ['referenced_table', 'referencing_table']
+  end
+
+  it "sort_table_pairs should not sort the tables if table_ordering is not enabled in the configuration" do
+    table_pairs = convert_table_array_to_table_pair_array([
+        'scanner_records',
+        'referencing_table',
+        'referenced_table',
+        'scanner_text_key',
+      ])
+    config = deep_copy(standard_config)
+    config.options[:table_ordering] = false
+    session = Session.new config
+    session.sort_table_pairs(table_pairs).should == table_pairs
+  end
+end
+