rubyrep 1.0.0

data/spec/replication_runner_spec.rb

@@ -0,0 +1,213 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe ReplicationRunner do
+  before(:each) do
+  end
+
+  it "should register itself with CommandRunner" do
+    CommandRunner.commands['replicate'][:command].should == ReplicationRunner
+    CommandRunner.commands['replicate'][: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 = ReplicationRunner.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 = ReplicationRunner.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 = ReplicationRunner.new
+    status = runner.process_options ["--help"]
+    runner.options.should == nil
+    status.should == 0
+  end
+
+  it "process_options should set the correct options" do
+    runner = ReplicationRunner.new
+    runner.process_options ["-c", "config_path"]
+    runner.options[:config_file].should == 'config_path'
+  end
+
+  it "run should not start a replication if the command line is invalid" do
+    $stderr.should_receive(:puts).any_number_of_times
+    ReplicationRunner.any_instance_should_not_receive(:execute) {
+      ReplicationRunner.run(["--nonsense"])
+    }
+  end
+
+  it "run should start a replication if the command line is correct" do
+    ReplicationRunner.any_instance_should_receive(:execute) {
+      ReplicationRunner.run(["--config=path"])
+    }
+  end
+
+  it "session should create and return the session" do
+    runner = ReplicationRunner.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 "pause_replication should not pause if next replication is already overdue" do
+    runner = ReplicationRunner.new
+    runner.stub!(:session).and_return(Session.new(standard_config))
+    waiter_thread = mock('waiter_thread')
+    waiter_thread.should_not_receive(:join)
+    runner.instance_variable_set(:@waiter_thread, waiter_thread)
+
+    runner.pause_replication # verify no wait during first run
+    runner.instance_variable_set(:@last_run, 1.hour.ago)
+    runner.pause_replication # verify no wait if overdue
+  end
+
+  it "pause_replication should pause for correct time frame" do
+    runner = ReplicationRunner.new
+    runner.stub!(:session).and_return(Session.new(deep_copy(standard_config)))
+    runner.session.configuration.stub!(:options).and_return(:replication_interval => 2)
+    waiter_thread = mock('waiter_thread')
+    runner.instance_variable_set(:@waiter_thread, waiter_thread)
+
+    now = Time.now
+    Time.stub!(:now).and_return(now)
+    runner.instance_variable_set(:@last_run, now - 1.seconds)
+    waiter_thread.should_receive(:join).and_return {|time| time.to_f.should be_close(1.0, 0.01); 0}
+
+    runner.pause_replication
+  end
+  
+  it "init_waiter should setup correct TERM signal processing" do
+    runner = ReplicationRunner.new
+    runner.stub!(:session).and_return(Session.new(standard_config))
+    
+    # simulate sending the TERM signal
+    Signal.should_receive(:trap).with('TERM').and_yield
+
+    runner.init_waiter
+
+    # verify the that any pause would have been prematurely finished and
+    # termination signal been set
+    runner.termination_requested.should be_true
+    runner.instance_variable_get(:@waiter_thread).should_not be_alive
+  end
+
+  it "prepare_replication should call ReplicationInitializer#prepare_replication" do
+    runner = ReplicationRunner.new
+    runner.stub!(:session).and_return(:dummy_session)
+    initializer  = mock('replication_initializer')
+    initializer.should_receive(:prepare_replication)
+    ReplicationInitializer.should_receive(:new).with(:dummy_session).and_return(initializer)
+    runner.prepare_replication
+  end
+
+  # Checks a specified number of times with specified waiting period between
+  # attempts if a given SQL query returns records.
+  # Returns +true+ if a record was found
+  # * +session+: an active Session object
+  # * +database+: either :+left+ or :+right+
+  # * +query+: sql query to execute
+  # * +max_attempts+: number of attempts to find the record
+  # * +interval+: waiting time in seconds between attempts
+  def check_for_record(session, database, query, max_attempts, interval)
+    found = false
+
+    max_attempts.times do
+      found = !!session.send(database).select_one(query)
+      break if found
+      sleep interval
+    end
+    
+    found
+  end
+
+  it "execute should catch and print exceptions" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      session = Session.new
+      runner = ReplicationRunner.new
+      runner.stub!(:session).and_return(session)
+      runner.stub!(:init_waiter)
+      runner.stub!(:prepare_replication)
+      runner.stub!(:pause_replication)
+      runner.should_receive(:termination_requested).twice.and_return(false, true)
+
+      session.should_receive(:refresh).and_return {raise "refresh failed"}
+
+      runner.execute
+      
+      $stderr.string.should =~ /Exception caught.*refresh failed/
+      $stderr.string.should =~ /replication_runner.rb:[0-9]+:in/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "execute should start the replication" do
+    config = deep_copy(standard_config)
+    config.options[:committer] = :buffered_commit
+    config.options[:replication_interval] = 0.01
+
+    # reset table selection
+    config.included_table_specs.replace ['scanner_left_records_only']
+    config.tables_with_options.clear
+    
+    session = Session.new config
+    org_stdout = $stdout
+    begin
+      $stdout = StringIO.new
+      runner = ReplicationRunner.new
+      runner.process_options ["-c", "./config/test_config.rb"]
+      runner.stub!(:session).and_return(session)
+
+      t = Thread.new {runner.execute}
+
+      # verify that the initial sync is done
+      found = check_for_record(
+        session, :right,
+        "select * from scanner_left_records_only where id = 1",
+        100, 0.01
+      )
+      t.should be_alive # verify that the replication thread didn't die
+      found.should be_true
+
+      session.left.execute "insert into scanner_left_records_only(name) values('bla')"
+
+      # verify that the replication works
+      check_for_record(
+        session, :right,
+        "select * from scanner_left_records_only where name = 'bla'",
+        100, 0.01
+      ).should be_true
+
+      runner.instance_variable_set(:@termination_requested, true)
+      t.join
+    ensure
+      $stdout = org_stdout
+      initializer = ReplicationInitializer.new session
+      [:left, :right].each do |database|
+        initializer.clear_sequence_setup database, 'scanner_left_records_only'
+        if initializer.trigger_exists?(database, 'scanner_left_records_only')
+          initializer.drop_trigger database, 'scanner_left_records_only'
+        end
+        session.send(database).execute "delete from scanner_left_records_only where name = 'bla'"
+      end
+      session.right.execute "delete from scanner_left_records_only"
+    end
+  end
+end

data/spec/replicators_spec.rb

@@ -0,0 +1,31 @@
+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 "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