rubyrep 1.2.0 → 2.0.0

data/spec/replicators_spec.rb

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

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

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

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

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

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

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

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

data/spec/spec.opts

@@ -1 +0,0 @@
---colour