rubyrep 1.2.0 → 2.0.0

data/spec/buffered_committer_spec.rb

@@ -1,274 +0,0 @@
-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_receive(:commit_db_transactions).twice
-    committer.should_receive(:begin_db_transactions).twice
-    committer.commit
-    committer.new_transaction?.should be_false
-    3.times {committer.commit}
-    committer.new_transaction?.should be_true
-  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

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

data/spec/committers_spec.rb

@@ -1,178 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe Committers do
-  before(:each) do
-    @old_committers = Committers.committers
-  end
-
-  after(:each) do
-    Committers.instance_variable_set :@committers, @old_committers
-  end
-  
-  it "committers should return empty hash if nil" do
-    Committers.instance_variable_set :@committers, nil
-    Committers.committers.should == {}
-  end
-  
-  it "committers should return the registered committers" do
-    Committers.instance_variable_set :@committers, :dummy_data
-    Committers.committers.should == :dummy_data
-  end
-  
-  it "register should register the provided commiter" do
-    Committers.instance_variable_set :@committers, nil
-    Committers.register :a_key => :a
-    Committers.register :b_key => :b
-    Committers.committers[:a_key].should == :a
-    Committers.committers[:b_key].should == :b
-  end
-end
-
-
-describe "Committer", :shared => true do
-  it "should support the right constructor interface" do
-    session = mock("session")
-    session.should_receive(:left).any_number_of_times \
-      .and_return(mock("left connection", :null_object => true))
-    session.should_receive(:right).any_number_of_times \
-      .and_return(mock("right connection", :null_object => true))
-    @committer.class.new session
-  end
-  
-  it "should proxy insert_record, update_record and delete_record calls" do
-    left_connection = mock("left connection", :null_object => true)
-    left_connection.should_receive(:insert_record).with("left", :dummy_insert_values)
-
-    right_connection = mock("right connection", :null_object => true)
-    right_connection.should_receive(:update_record).with("right", :dummy_update_values, :dummy_org_key)
-    right_connection.should_receive(:delete_record).with("right", :dummy_delete_values)
-
-    session = mock("session")
-    session.should_receive(:left).any_number_of_times.and_return(left_connection)
-    session.should_receive(:right).any_number_of_times.and_return(right_connection)
-
-    committer = @committer.class.new session
-
-    committer.insert_record :left, 'left', :dummy_insert_values
-    committer.update_record :right, 'right', :dummy_update_values, :dummy_org_key
-    committer.delete_record :right, 'right', :dummy_delete_values
-  end
-  
-  it "should support finalize" do
-    @committer.finalize(false)
-  end
-end
-
-describe Committers::DefaultCommitter do
-  before(:each) do
-    @session = mock("session")
-    @session.should_receive(:left).any_number_of_times.and_return(:left_connection)
-    @session.should_receive(:right).any_number_of_times.and_return(:right_connection)
-    @committer = Committers::DefaultCommitter.new @session
-  end
-
-  it "should register itself" do
-    Committers.committers[:default].should == Committers::DefaultCommitter
-  end
-  
-  it "initialize should store the provided parameters" do
-    @committer.session.should == @session
-    @committer.connections \
-      .should == {:left => @session.left, :right => @session.right}
-  end
-
-  it "new_transaction? should return false" do
-    @committer.new_transaction?.should be_false
-  end
-  
-  it_should_behave_like "Committer"
-end
-
-describe Committers::NeverCommitter do
-  before(:each) do
-    @old_session = Committers::NeverCommitter.current_session
-    Committers::NeverCommitter.current_session = nil
-    @session = mock("session")
-    @session.should_receive(:left).any_number_of_times \
-      .and_return(mock("left connection", :null_object => true))
-    @session.should_receive(:right).any_number_of_times \
-      .and_return(mock("right connection", :null_object => true))
-    @committer = Committers::NeverCommitter.new @session
-  end
-  
-  after(:each) do
-    Committers::NeverCommitter.current_session = @old_session
-  end
-
-  it "should register itself" do
-    Committers.committers[:never_commit].should == Committers::NeverCommitter
-  end
-  
-  it "initialize should store the provided parameters" do
-    @committer.session.should == @session
-    @committer.connections \
-      .should == {:left => @session.left, :right => @session.right}
-  end
-  
-  it "initialize should rollback the previous current session and then register the new one as current session" do
-    old_session = mock("old session", :null_object => true)
-    new_session = mock("new session", :null_object => true)
-    Committers::NeverCommitter.current_session = old_session
-    Committers::NeverCommitter.should_receive(:rollback_current_session)
-    
-    Committers::NeverCommitter.new new_session
-    Committers::NeverCommitter.current_session.should == new_session
-  end
-  
-  it "initialize should start new transactions" do
-    # Ensure that initialize handles the case of no previous database session 
-    # being present
-    Committers::NeverCommitter.current_session = nil
-    new_session = mock("new session")
-
-    left_connection = mock("left connection")
-    left_connection.should_receive :begin_db_transaction
-    new_session.should_receive(:left).any_number_of_times.and_return(left_connection)
-
-    right_connection = mock("right connection")
-    right_connection.should_receive :begin_db_transaction
-    new_session.should_receive(:right).any_number_of_times.and_return(right_connection)
-
-    @committer = Committers::NeverCommitter.new new_session
-  end
-  
-  it "rollback_current_session should rollback current session" do
-    old_session = mock("old session")
-
-    left_connection = mock("left connection")
-    left_connection.should_receive :rollback_db_transaction
-    old_session.should_receive(:left).and_return(left_connection)
-
-    right_connection = mock("right connection")
-    right_connection.should_receive :rollback_db_transaction
-    old_session.should_receive(:right).and_return(right_connection)
-    
-    Committers::NeverCommitter.current_session = old_session
-    Committers::NeverCommitter.rollback_current_session
-  end
-  
-  it "should work will real sessions" do
-    session = Session.new(standard_config)
-    Committers::NeverCommitter.new session
-    Committers::NeverCommitter.new session
-    Committers::NeverCommitter.rollback_current_session
-  end
-  
-  it "should work will real proxied sessions" do
-    ensure_proxy
-    session = Session.new(proxied_config)
-    Committers::NeverCommitter.new session
-    Committers::NeverCommitter.new session   
-    Committers::NeverCommitter.rollback_current_session
-  end
-  
-  it_should_behave_like "Committer"
-  
-end