andyjeffries-rubyrep 1.2.1

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

data/spec/committers_spec.rb

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

data/spec/configuration_spec.rb

@@ -0,0 +1,203 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+include RR
+
+describe Configuration do
+  before(:each) do
+  end
+
+  it "initialize should set #left and #right to empty hashes" do
+    config = Configuration.new
+    config.left.should == {}
+    config.right.should == {}
+  end
+  
+  it "initialize should set #options to the default options" do
+    config = Configuration.new
+    config.options.should == Configuration::DEFAULT_OPTIONS
+  end
+
+  it "options= should merge the provided into the existing options" do
+    config = Configuration.new
+    config.options = {:bla => :bla}
+    config.options = {:bla => :blub}
+    config.options[:bla].should == :blub
+  end
+
+  it "each_matching_option should yield if general option matches" do
+    config = Configuration.new
+    config.options = {:bla => :blub}
+    yielded = []
+    config.each_matching_option(:bla) {|spec, value| yielded << [spec, value]}
+    yielded.should == [[nil, :blub]]
+  end
+
+  it "each_matching_option should yield if table specific options match" do
+    config = Configuration.new
+    config.options = {:a => 1}
+    config.add_table_options 't1', :a => 2
+    config.add_table_options 't2', :b => 3
+    config.add_table_options 't3', :a => 4
+    yielded = []
+    config.each_matching_option(:a) {|spec, value| yielded << [spec, value]}
+    yielded.should == [
+      [nil,  1],
+      ['t1', 2],
+      ['t3', 4]
+    ]
+  end
+
+  it "each_matching_option should not yield unmatching options" do
+    config = Configuration.new
+    config.options = {:a => :blub}
+    config.add_table_options 'dummy_table', :b => :blub
+    yielded = []
+    config.each_matching_option(:c) {|spec, value| yielded << [spec, value]}
+    yielded.should == []
+  end
+
+  it "options_for_table should return the general options if there are no table specific options at all" do
+    config = Configuration.new
+    config.options_for_table('b').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(Replicators::TwoWayReplicator.default_options.clone).
+      merge(config.options)
+  end
+
+  it "included_table_specs should return the list of included table specifications" do
+    config = Configuration.new
+    config.include_tables('a', {:bla => :blub})
+    config.include_tables('a, b')
+    config.include_tables(/a/)
+    config.included_table_specs.should == ['a', 'a, b', /a/]
+  end
+
+  it "included_table_specs should save the options if provided" do
+    config = Configuration.new
+    config.include_tables('a', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "include_tables should include the specified table specs" do
+    config = Configuration.new
+    config.include_tables('a')
+    config.include_tables(/b/)
+    config.included_table_specs.include?('a').should be_true
+    config.included_table_specs.include?(/b/).should be_true
+  end
+
+  it "include_table should alias to include_tables" do
+    config = Configuration.new
+    config.include_table('a')
+    config.included_table_specs.include?('a').should be_true
+  end
+
+  it "exclude_tables should exclude the specified table specs" do
+    config = Configuration.new
+    config.exclude_tables('a')
+    config.exclude_tables(/b/)
+    config.excluded_table_specs.include?('a').should be_true
+    config.excluded_table_specs.include?(/b/).should be_true
+  end
+
+  it "exclude_table should alias to exclude_tables" do
+    config = Configuration.new
+    config.exclude_table('a')
+    config.excluded_table_specs.include?('a').should be_true
+  end
+
+  it "exclude_rubyrep_tables should exclude the rubyrep infrastructure tables" do
+    config = Configuration.new
+    config.exclude_rubyrep_tables
+    config.excluded_table_specs.include?(/^rr_.*/).should be_true
+  end
+
+  it "excluded_table_specs should return the list of excluded table specifications" do
+    config = Configuration.new
+    config.exclude_tables('a')
+    config.exclude_tables('a, b')
+    config.exclude_tables(/a/)
+    config.excluded_table_specs.should == ['a', 'a, b', /a/]
+  end
+
+  it "options_for_table should return the general options if there are no matching table specific options" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.options_for_table('b').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(Replicators::TwoWayReplicator.default_options.clone).
+      merge(config.options)
+  end
+
+  it "options_for_table should return table specific options mixed in with default options" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(Replicators::TwoWayReplicator.default_options.clone).
+      merge(config.options).
+      merge(:bla => :blub)
+  end
+
+  it "options_for_table should return last added version of added options for matching table spec" do
+    config = Configuration.new
+    config.include_tables(/a/, {:bla => :blub})
+    config.include_tables('a', {:bla => :blok})
+    config.include_tables(/x/, {:bla => :bar})
+    config.include_tables('y', {:bla => :foo})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(Replicators::TwoWayReplicator.default_options.clone).
+      merge(config.options).
+      merge(:bla => :blok)
+  end
+
+  it "options_for_table should match against table pair specs" do
+    config = Configuration.new
+    config.add_table_options('a, b', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "options_for_table should match against regular expression specs" do
+    config = Configuration.new
+    config.add_table_options(/a/, {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "options_for_table should match against pure table name specs" do
+    config = Configuration.new
+    config.add_table_options('a', {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "add_table_options should not create table_spec duplicates" do
+    config = Configuration.new
+    config.add_table_options(/a/, {:bla => :blub})
+    config.add_table_options(/a/, {:foo => :bar})
+    config.options_for_table('a').should == \
+      Syncers::TwoWaySyncer.default_options.clone.
+      merge(Replicators::TwoWayReplicator.default_options.clone).
+      merge(config.options).
+      merge(:bla => :blub, :foo => :bar)
+  end
+
+  it "add_table_option should alias to add_table_options" do
+    config = Configuration.new
+    config.add_table_option(/a/, {:bla => :blub})
+    config.options_for_table('a')[:bla].should == :blub
+  end
+
+  it "add_table_options should include default syncer options" do
+    config = Configuration.new
+    config.options = {:syncer => :one_way}
+
+    # overwrite one syncer option
+    config.add_table_options(/a/, {:delete => true})
+
+    options = config.options_for_table('a')
+    Syncers::OneWaySyncer.default_options.each do |key, value|
+      options[key].should == value unless key == :delete
+    end
+    options[:delete].should == true
+  end
+end