rubyrep 1.0.0

data/spec/base_runner_spec.rb

@@ -0,0 +1,218 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe BaseRunner do
+  before(:each) do
+  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 = BaseRunner.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 = BaseRunner.new
+    status = runner.process_options ["table"]
+    runner.options.should == nil
+    status.should == 1
+  end
+
+  it "process_options should show the summary description (if usage is printed)" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      base_runner = BaseRunner.new
+      base_runner.should_receive(:summary_description).
+        and_return("my_summary_description")
+      base_runner.process_options ["--help"]
+      $stderr.string.should =~ /my_summary_description/
+    ensure
+      $stderr = org_stderr
+    end
+  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 = BaseRunner.new
+    status = runner.process_options ["--help"]
+    runner.options.should == nil
+    status.should == 0
+  end
+  
+  it "process_options should set the correct options" do
+    runner = BaseRunner.new
+    runner.process_options ["-c", "config_path", "table_spec1", "table_spec2"]
+    runner.options[:config_file].should == 'config_path'
+    runner.options[:table_specs].should == ['table_spec1', 'table_spec2']
+  end
+
+  it "process_options should add runner specific options" do
+    BaseRunner.any_instance_should_receive(:add_specific_options) do
+      runner = BaseRunner.new
+      runner.process_options ["-c", "config_path"]
+    end
+  end
+  
+  it "process_options should assign the command line specified report printer" do
+    org_printers = ScanReportPrinters.printers
+    begin
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, nil }
+      
+      ScanReportPrinters.register :dummy_printer_class, "-y", "--printer_y[=arg]", "description"
+      
+      runner = BaseRunner.new
+      runner.stub!(:session)
+      runner.process_options ["-c", "config_path", "--printer_y=arg_for_y", "table_spec"]
+      runner.report_printer_class.should == :dummy_printer_class
+      runner.report_printer_arg.should == 'arg_for_y'
+    ensure
+      ScanReportPrinters.instance_eval { class_variable_set :@@report_printers, org_printers }
+    end
+  end
+
+  it "process_options should assign the command line specified progress printer class" do
+    org_printers = ScanProgressPrinters.printers
+    begin
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, nil }
+
+      printer_y_class = mock("printer_y_class")
+      printer_y_class.should_receive(:arg=)
+
+      ScanProgressPrinters.register :printer_y_key, printer_y_class, "-y", "--printer_y[=arg]", "description"
+
+      runner = BaseRunner.new
+      runner.process_options ["-c", "config_path", "-y", "arg_for_y"]
+      runner.progress_printer.should == printer_y_class
+    ensure
+      ScanProgressPrinters.instance_eval { class_variable_set :@@progress_printers, org_printers }
+    end
+  end
+
+  it "add_specific_options should not do anything" do
+    BaseRunner.new.add_specific_options nil
+  end
+
+  it "create_processor should not do anything" do
+    BaseRunner.new.create_processor "dummy_left_table", "dummy_right_table"
+  end
+
+  it "prepare_table_pairs should return the provided table pairs unmodied" do
+    BaseRunner.new.prepare_table_pairs(:dummy_table_pairs).
+      should == :dummy_table_pairs
+  end
+  
+  it "run should not start a scan if the command line is invalid" do
+    $stderr.should_receive(:puts).any_number_of_times
+    BaseRunner.any_instance_should_not_receive(:execute) {
+      BaseRunner.run(["--nonsense"])
+    }
+  end
+
+  it "run should start a scan if the command line is correct" do
+    BaseRunner.any_instance_should_receive(:execute) {
+      BaseRunner.run(["--config=path", "table"])
+    }
+  end
+
+  it "report_printer should create and return the printer as specified per command line options" do
+    printer_class = mock("printer class")
+    printer_class.should_receive(:new).with(:dummy_session, :dummy_arg).and_return(:dummy_printer)
+    runner = BaseRunner.new
+    runner.stub!(:session).and_return(:dummy_session)
+    runner.report_printer_class = printer_class
+    runner.report_printer_arg = :dummy_arg
+    runner.report_printer.should == :dummy_printer
+    runner.report_printer # ensure the printer object is cached
+  end
+  
+  it "report_printer should return the ScanSummaryReporter if no other printer was chosen" do
+    runner = BaseRunner.new
+    runner.stub!(:session)
+    runner.report_printer.should be_an_instance_of(ScanReportPrinters::ScanSummaryReporter)
+  end
+
+  it "progress_printer should return the config file specified printer if none was give via command line" do
+    runner = BaseRunner.new
+    runner.options = {
+      :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
+      :table_specs => ["scanner_records", "extender_one_record"]
+    }
+    config_specified_printer_key = Session.new(standard_config).configuration.options[:scan_progress_printer]
+    config_specified_printer_class = ScanProgressPrinters.
+      printers[config_specified_printer_key][:printer_class]
+    runner.progress_printer.should == config_specified_printer_class
+  end
+  
+  it "signal_scanning_completion should signal completion if the scan report printer supports it" do
+    printer = mock("printer")
+    printer.should_receive(:scanning_finished)
+    printer.should_receive(:respond_to?).with(:scanning_finished).and_return(true)
+    runner = BaseRunner.new
+    runner.stub!(:report_printer).and_return(printer)
+    runner.signal_scanning_completion
+  end
+  
+  it "signal_scanning_completion should not signal completion if the scan report printer doesn't supports it" do
+    printer = mock("printer")
+    printer.should_not_receive(:scanning_finished)
+    printer.should_receive(:respond_to?).with(:scanning_finished).and_return(false)
+    runner = BaseRunner.new
+    runner.stub!(:report_printer).and_return(printer)
+    runner.signal_scanning_completion
+  end
+
+  it "execute should process the specified tables" do
+    org_stdout = $stdout
+    $stdout = StringIO.new
+    begin
+      runner = BaseRunner.new
+      runner.options = {
+        :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
+        :table_specs => ["scanner_records", "extender_one_record"]
+      }
+
+      # create and install a dummy processor
+      processor = mock("dummy_processor")
+      processor.should_receive(:run).twice.and_yield(:left, :dummy_row)
+
+      # verify that the scanner receives the progress printer
+      runner.stub!(:progress_printer).and_return(:dummy_printer_class)
+      processor.should_receive(:progress_printer=).twice.with(:dummy_printer_class)
+
+      runner.should_receive(:create_processor).twice.and_return(processor)
+
+      # verify that the scanning_completion signal is given to scan report printer
+      runner.should_receive :signal_scanning_completion
+
+      runner.execute
+
+      # verify that rubyrep infrastructure tables were excluded
+      runner.session.configuration.excluded_table_specs.include?(/^rr_.*/).should be_true
+
+      $stdout.string.should =~ /scanner_records.* 1\n/
+      $stdout.string.should =~ /extender_one_record.* 1\n/
+    ensure
+      $stdout = org_stdout
+    end
+  end
+
+  it "table_pairs should return the prepared table pairs" do
+    runner = BaseRunner.new
+    runner.options = {
+      :config_file => "#{File.dirname(__FILE__)}/../config/test_config.rb",
+      :table_specs => ['scanner_records']
+    }
+    runner.should_receive(:prepare_table_pairs).with([
+      {:left => 'scanner_records', :right => 'scanner_records'},
+    ]).and_return(:dummy_table_pairs)
+    runner.table_pairs.should == :dummy_table_pairs
+  end
+end

data/spec/buffered_committer_spec.rb

@@ -0,0 +1,271 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Committers::BufferedCommitter do
+  before(:each) do
+    Initializer.configuration = standard_config
+  end
+
+  it "should register itself" do
+    Committers.committers[:buffered_commit].should == Committers::BufferedCommitter
+  end
+
+  # Stubs out the starting of transactions in the given Session.
+  def stub_begin_transaction(session)
+    session.left.stub! :begin_db_transaction
+    session.right.stub! :begin_db_transaction
+  end
+
+  # Stubs out the executing of SQL statements for the given Session.
+  def stub_execute(session)
+    session.left.stub! :execute
+    session.right.stub! :execute
+  end
+
+  it "trigger_mode_switcher should return and if necessary create the trigger mode switcher" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    switcher = committer.trigger_mode_switcher
+    switcher.should be_an_instance_of(TriggerModeSwitcher)
+
+    committer.trigger_mode_switcher.should == switcher # ensure it is only created one
+  end
+
+  it "exclude_rr_activity should exclude the rubyrep activity for the specified table" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.trigger_mode_switcher.should_receive(:exclude_rr_activity).with(:left, 'dummy_table')
+    committer.exclude_rr_activity :left, 'dummy_table'
+  end
+
+  it "activity_marker_table should return the correct table name" do
+    config = deep_copy(standard_config)
+    config.options[:rep_prefix] = 'rx'
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.activity_marker_table.should == 'rx_running_flags'
+  end
+
+  it "maintain_activity_status should return true if activity marker table exists" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.maintain_activity_status?.should be_true
+  end
+
+  it "maintain_activity_status should return false if activity marker does not exist" do
+    config = deep_copy(standard_config)
+    config.options[:rep_prefix] = 'rx'
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.maintain_activity_status?.should be_false
+  end
+
+  it "commit_frequency should return the configured commit frequency" do
+    config = deep_copy(standard_config)
+    config.options[:commit_frequency] = 5
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.commit_frequency.should == 5
+  end
+
+  it "commit_frequency should return the the default commit frequency if nothing else is configured" do
+    config = deep_copy(standard_config)
+    config.options.delete :commit_frequency
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+    committer.commit_frequency.should == Committers::BufferedCommitter::DEFAULT_COMMIT_FREQUENCY
+  end
+
+  it "initialize should start transactions and setup rubyrep activity filtering" do
+    session = nil
+    begin
+      session = Session.new
+      session.left.should_receive(:begin_db_transaction)
+      session.right.should_receive(:begin_db_transaction)
+      session.left.select_one("select * from rr_running_flags").should be_nil # verify starting situation
+      committer = Committers::BufferedCommitter.new(session)
+
+      # rubyrep activity should be marked
+      session.left.select_one("select * from rr_running_flags").should_not be_nil
+      session.right.select_one("select * from rr_running_flags").should_not be_nil
+    ensure
+      session.left.execute "delete from rr_running_flags" if session
+      session.right.execute "delete from rr_running_flags" if session
+    end
+  end
+
+  it "commit_db_transactions should commit the transactions in both databases" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_receive(:commit_db_transaction)
+    session.right.should_receive(:commit_db_transaction)
+    committer.commit_db_transactions
+  end
+
+  it "commit_db_transactions should clear the activity marker table" do
+    session = Session.new
+    stub_begin_transaction session
+    session.left.stub!(:commit_db_transaction)
+    session.right.stub!(:commit_db_transaction)
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_receive(:execute).with("delete from rr_running_flags")
+    session.right.should_receive(:execute).with("delete from rr_running_flags")
+    committer.commit_db_transactions
+  end
+
+  it "commit_db_transactions should not clear the activity marker table if it doesn't exist" do
+    config = deep_copy(standard_config)
+    config.options[:rep_prefix] = 'rx'
+    session = Session.new config
+    stub_begin_transaction session
+    session.left.stub!(:commit_db_transaction)
+    session.right.stub!(:commit_db_transaction)
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_not_receive(:execute)
+    session.right.should_not_receive(:execute)
+    committer.commit_db_transactions
+  end
+
+  it "begin_db_transactions should begin new transactions in both databases" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_receive(:begin_db_transaction)
+    session.right.should_receive(:begin_db_transaction)
+    committer.begin_db_transactions
+  end
+
+  it "begin_db_transactions should insert a record into the activity marker table" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_receive(:execute).with("insert into rr_running_flags values(1)")
+    session.right.should_receive(:execute).with("insert into rr_running_flags values(1)")
+    committer.begin_db_transactions
+  end
+
+  it "begin_db_transactions should not clear the activity marker table if it doesn't exist" do
+    config = deep_copy(standard_config)
+    config.options[:rep_prefix] = 'rx'
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_not_receive(:execute)
+    session.right.should_not_receive(:execute)
+    committer.begin_db_transactions
+  end
+
+  it "rollback_db_transactions should roll back the transactions in both databases" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    session.left.should_receive(:rollback_db_transaction)
+    session.right.should_receive(:rollback_db_transaction)
+    committer.rollback_db_transactions
+  end
+
+  it "commit should only commit and start new transactions if the specified number of changes have been executed" do
+    config = deep_copy(standard_config)
+    config.options[:commit_frequency] = 2
+    session = Session.new config
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_not_receive(:commit_db_transactions).twice
+    committer.should_not_receive(:begin_db_transactions).twice
+    4.times {committer.commit}
+  end
+
+  it "insert_record should commit" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_receive(:exclude_rr_activity).with(:right, 'right_table').ordered
+    session.right.should_receive(:insert_record).with('right_table', :dummy_values).ordered
+    committer.should_receive(:commit).ordered
+    
+    committer.insert_record(:right, 'right_table', :dummy_values)
+  end
+
+  it "update_record should commit" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_receive(:exclude_rr_activity).with(:right, 'right_table').ordered
+    session.right.should_receive(:update_record).with('right_table', :dummy_values, :dummy_org_key).ordered
+    committer.should_receive(:commit).ordered
+
+    committer.update_record(:right, 'right_table', :dummy_values, :dummy_org_key)
+  end
+
+  it "delete_record should commit" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_receive(:exclude_rr_activity).with(:right, 'right_table').ordered
+    session.right.should_receive(:delete_record).with('right_table', :dummy_values).ordered
+    committer.should_receive(:commit).ordered
+
+    committer.delete_record(:right, 'right_table', :dummy_values)
+  end
+
+  it "finalize should commit the transactions if called with success = true" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_receive(:commit_db_transactions)
+
+    committer.finalize true
+  end
+
+  it "finalize should rollbackup the transactions if called with success = false" do
+    session = Session.new
+    stub_begin_transaction session
+    stub_execute session
+    committer = Committers::BufferedCommitter.new(session)
+
+    committer.should_receive(:rollback_db_transactions)
+
+    committer.finalize false
+  end
+end
+

data/spec/command_runner_spec.rb

@@ -0,0 +1,145 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe CommandRunner do
+  before(:each) do
+    @org_commands = CommandRunner.commands
+    CommandRunner.instance_variable_set :@commands, nil
+  end
+
+  after(:each) do
+    CommandRunner.instance_variable_set :@commands, @org_commands
+  end
+
+  it "show_version should print the version string" do
+    $stdout.should_receive(:puts).with(/rubyrep version ([0-9]+\.){2}[0-9]+/)
+    CommandRunner.show_version
+  end
+
+  it "register should register commands, commands should return it" do
+    CommandRunner.register :bla => :bla_command
+    CommandRunner.register :blub => :blub_command
+    CommandRunner.commands.should == {
+      :bla => :bla_command,
+      :blub => :blub_command
+    }
+  end
+
+  it "run should print a short help if --help is specified" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      CommandRunner.register 'c1' => {:description => 'desc 1'}, 'c2' => {:description => 'desc 2'}
+      CommandRunner.run(['--help'])
+      $stderr.string.should =~ /Usage/
+      $stderr.string.should =~ /c1.*desc 1\n/
+      $stderr.string.should =~ /c2.*desc 2\n/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "run should print help if no command line parameters are given" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      CommandRunner.run([]).should == 1
+      $stderr.string.should =~ /Available commands/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "run should print help if --help or help without further params is given" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      CommandRunner.run(['--help']).should == 0
+      $stderr.string.should =~ /Available commands/
+      $stderr = StringIO.new
+      CommandRunner.run(['help']).should == 0
+      $stderr.string.should =~ /Available commands/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "run should print version if --version is given" do
+    CommandRunner.should_receive(:show_version)
+    CommandRunner.run(['--version'])
+  end
+
+  it "run should call the specified command with the specified params" do
+    c = mock('dummy_command')
+    c.should_receive(:run).with(['param1', 'param2'])
+    CommandRunner.register 'dummy_command' => {:command => c}
+    CommandRunner.run(['dummy_command', 'param1', 'param2'])
+  end
+
+  it "run should print help if unknown command is given" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      CommandRunner.run('non-existing-command').should == 1
+      $stderr.string.should =~ /Available commands/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "run should print stacktrace if --verbose option is given" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      c = mock('dummy_command')
+      c.stub!(:run).and_return {raise 'bla'}
+      CommandRunner.register 'dummy_command' => {:command => c}
+      CommandRunner.run(['--verbose', 'dummy_command', '-c', 'non_existing_file']).should == 1
+      $stderr.string.should =~ /Exception caught/
+      $stderr.string.should =~ /command_runner.rb:[0-9]+:in /
+
+      # also verify that no stacktrace is printed if --verbose is not specified
+      $stderr = StringIO.new
+      CommandRunner.run(['dummy_command', '-c', 'non_existing_file']).should == 1
+      $stderr.string.should =~ /Exception caught/
+      $stderr.string.should_not =~ /command_runner.rb:[0-9]+:in /
+    ensure
+      $stderr = org_stderr
+    end
+  end
+
+  it "rubyrep should call CommandRunner#run" do
+    CommandRunner.should_receive(:run).with(ARGV).and_return(0)
+    Kernel.any_instance_should_receive(:exit) {
+      load File.dirname(__FILE__) + '/../bin/rubyrep'
+    }
+  end
+end
+
+describe HelpRunner do
+  it "should register itself" do
+    CommandRunner.commands['help'][:command].should == HelpRunner
+    CommandRunner.commands['help'][:description].should be_an_instance_of(String)
+  end
+
+  it "run should call help for the specified command" do
+    CommandRunner.should_receive(:run).with(['dummy_command', '--help'])
+    HelpRunner.run(['dummy_command'])
+  end
+
+  it "run should print help for itself if '--help' or 'help' is specified" do
+    org_stderr = $stderr
+    $stderr = StringIO.new
+    begin
+      HelpRunner.run(['--help'])
+      $stderr.string.should =~ /Shows the help for the specified command/
+
+      $stderr = StringIO.new
+      HelpRunner.run(['help'])
+      $stderr.string.should =~ /Shows the help for the specified command/
+    ensure
+      $stderr = org_stderr
+    end
+  end
+end