rubyrep 1.2.0 → 2.0.0

data/spec/two_way_syncer_spec.rb

@@ -1,256 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe Syncers::TwoWaySyncer do
-  before(:each) do
-    Initializer.configuration = deep_copy(standard_config)
-    Initializer.configuration.options = {:syncer => :two_way}
-  end
-
-  it "should register itself" do
-    Syncers::syncers[:two_way].should == Syncers::TwoWaySyncer
-  end
-
-  it "initialize should store sync_helper" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    syncer.sync_helper.should == helper
-  end
-
-  it "initialize should throw an error if options are invalid" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    base_options = {
-      :syncer => :two_way,
-      :left_record_handling => :ignore,
-      :right_record_handling => :ignore,
-      :sync_conflict_handling => :ignore,
-      :logged_sync_events => []
-    }
-
-    # Verify that correct options don't raise errors.
-    helper.stub!(:sync_options).and_return(base_options)
-    lambda {Syncers::TwoWaySyncer.new(helper)}.should_not raise_error
-
-    # Also lambda options should not raise errors.
-    l = lambda {}
-    helper.stub!(:sync_options).and_return(base_options.merge(
-        {
-          :left_record_handling => l,
-          :right_record_handling => l,
-          :sync_conflict_handling => l
-        })
-    )
-    lambda {Syncers::TwoWaySyncer.new(helper)}.should_not raise_error
-
-    # Invalid options should raise errors
-    invalid_options = [
-      {:left_record_handling => :invalid_left_option},
-      {:right_record_handling => :invalid_right_option},
-      {:sync_conflict_handling => :invalid_conflict_option},
-      {:logged_sync_events => [:invalid_logging_option]}
-    ]
-    invalid_options.each do |options|
-      helper.stub!(:sync_options).and_return(base_options.merge(options))
-      lambda {Syncers::TwoWaySyncer.new(helper)}.should raise_error(ArgumentError)
-    end
-  end
-
-  it "log_sync_outcome should not log if not so configured" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-
-    helper = SyncHelper.new(sync)
-    helper.should_not_receive(:log_sync_outcome)
-    helper.stub!(:sync_options).and_return(
-      {
-        :rep_prefix => 'rr',
-        :left_record_handling => :ignore,
-        :right_record_handling => :ignore,
-        :sync_conflict_handling => :ignore,
-        :logged_sync_events => []
-      })
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    [:left, :right, :conflict].each do |diff_type|
-      syncer.sync_difference(diff_type, :dummy_row)
-    end
-
-    helper = SyncHelper.new(sync)
-    helper.should_not_receive(:log_sync_outcome)
-    helper.stub!(:sync_options).and_return(
-      {
-        :rep_prefix => 'rr',
-        :left_record_handling => :insert,
-        :right_record_handling => :insert,
-        :sync_conflict_handling => :right_wins,
-        :logged_sync_events => [:ignored_changes, :ignored_conflicts]
-      })
-    helper.stub!(:insert_record)
-    helper.stub!(:update_record)
-    syncer.sync_difference :left, :dummy_row
-    syncer.sync_difference :right, :dummy_row
-    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
-  end
-
-  it "log_sync_outcome should log sync actions correctly" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-
-    helper = SyncHelper.new(sync)
-    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'left_record', :insert).ordered
-    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'right_record', :insert).ordered
-    helper.should_receive(:log_sync_outcome).with(:left_dummy_row, 'conflict', :right_wins).ordered
-    helper.stub!(:sync_options).and_return(
-      {
-        :rep_prefix => 'rr',
-        :left_record_handling => :insert,
-        :right_record_handling => :insert,
-        :sync_conflict_handling => :right_wins,
-        :logged_sync_events => [:all_changes, :all_conflicts]
-      })
-    helper.stub!(:insert_record)
-    helper.stub!(:update_record)
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    syncer.sync_difference :left, :dummy_row
-    syncer.sync_difference :right, :dummy_row
-    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
-  end
-
-  it "log_sync_outcome should log ignored syncs correctly" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-
-    helper = SyncHelper.new(sync)
-    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'left_record', :ignore).ordered
-    helper.should_receive(:log_sync_outcome).with(:dummy_row, 'right_record', :ignore).ordered
-    helper.should_receive(:log_sync_outcome).with(:left_dummy_row, 'conflict', :ignore).ordered
-    helper.stub!(:sync_options).and_return(
-      {
-        :rep_prefix => 'rr',
-        :left_record_handling => :ignore,
-        :right_record_handling => :ignore,
-        :sync_conflict_handling => :ignore,
-        :logged_sync_events => [:ignored_changes, :ignored_conflicts]
-      })
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    syncer.sync_difference :left, :dummy_row
-    syncer.sync_difference :right, :dummy_row
-    syncer.sync_difference :conflict, [:left_dummy_row, :right_dummy_row]
-  end
-
-  it "sync_difference should not do anything if ignore option is given" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => :ignore,
-        :right_record_handling => :ignore,
-        :sync_conflict_handling => :ignore,
-        :logged_sync_events => []
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_not_receive(:delete_record)
-    helper.should_not_receive(:update_record)
-    helper.should_not_receive(:insert_record)
-
-    [:left, :right, :conflict].each do |diff_type|
-      syncer.sync_difference(diff_type, :dummy_row)
-    end
-  end
-
-  it "sync_difference should call the provided Proc objects" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-
-    lambda_parameters = []
-    l = lambda do |sync_helper, type, row|
-      lambda_parameters << [sync_helper, type, row]
-    end
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => l,
-        :right_record_handling => l,
-        :sync_conflict_handling => l,
-        :logged_sync_events => [:ignored_conflicts]
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    syncer.sync_difference(:left, :dummy_left)
-    syncer.sync_difference(:right, :dummy_right)
-    syncer.sync_difference(:conflict, [:dummy_left2, :dummy_right2])
-
-    lambda_parameters.should == [
-      [helper, :left, :dummy_left],
-      [helper, :right, :dummy_right],
-      [helper, :conflict, [:dummy_left2, :dummy_right2]]
-    ]
-  end
-
-  it "sync_difference should delete left or right records from source if that option is given" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => :delete,
-        :right_record_handling => :delete,
-        :sync_conflict_handling => :ignore,
-        :logged_sync_events => [:ignored_conflicts]
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:delete_record).with(:left, 'scanner_records', :dummy_left)
-    helper.should_receive(:delete_record).with(:right, 'scanner_records', :dummy_right)
-    syncer.sync_difference(:left, :dummy_left)
-    syncer.sync_difference(:right, :dummy_right)
-  end
-
-  it "sync_difference should insert left or right records to target if that option is given" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => :insert,
-        :right_record_handling => :insert,
-        :sync_conflict_handling => :ignore,
-        :logged_sync_events => [:ignored_conflicts]
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:insert_record).with(:right, 'scanner_records', :dummy_left)
-    helper.should_receive(:insert_record).with(:left, 'scanner_records', :dummy_right)
-    syncer.sync_difference(:left, :dummy_left)
-    syncer.sync_difference(:right, :dummy_right)
-  end
-
-  it "sync_difference should update the left database if conflict handling is specified with :right_wins" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => :ignore,
-        :right_record_handling => :ignore,
-        :sync_conflict_handling => :right_wins,
-        :logged_sync_events => [:ignored_conflicts]
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:left, 'scanner_records', :dummy_right)
-    syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
-  end
-
-  it "sync_difference should update the right database if conflict handling is specified with :left_wins" do
-    sync = TableSync.new(Session.new, 'scanner_records')
-    helper = SyncHelper.new(sync)
-    helper.stub!(:sync_options).and_return(
-      {
-        :left_record_handling => :ignore,
-        :right_record_handling => :ignore,
-        :sync_conflict_handling => :left_wins,
-        :logged_sync_events => [:ignored_conflicts]
-      })
-
-    syncer = Syncers::TwoWaySyncer.new(helper)
-    helper.should_receive(:update_record).with(:right, 'scanner_records', :dummy_left)
-    syncer.sync_difference(:conflict, [:dummy_left, :dummy_right])
-  end
-end

data/spec/type_casting_cursor_spec.rb

@@ -1,50 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe TypeCastingCursor do
-  before(:each) do
-    Initializer.configuration = standard_config
-  end
-
-  it "initialize should cache the provided cursor and the retrieved Column objects" do
-    cursor = TypeCastingCursor.new Session.new.left, 'extender_type_check', :dummy_org_cursor
-    cursor.columns['id'].name.should == 'id'
-    cursor.columns['decimal_test'].name.should == 'decimal_test'
-    cursor.org_cursor.should == :dummy_org_cursor
-  end
-  
-  it "next_row should delegate next? and clear to the original cursor" do
-    session = Session.new
-    cursor = session.left.select_cursor(
-      :query => "select id from extender_type_check where id = 1",
-      :table => "extender_type_check"
-    )
-    cursor.next?.should be_true
-    row = cursor.next_row
-    cursor.next?.should be_false
-    cursor.clear
-  end
-  
-  it "next_row should cast rows - including uncommon data types - correctly" do
-    session = Session.new
-    row = session.left.select_record(
-      :query => "select id, decimal_test, timestamp, binary_test from extender_type_check where id = 1",
-      :table => "extender_type_check"
-    )
-
-    # verify that the row fields have been converted to the correct types
-    row['id'].should be_an_instance_of(Fixnum)
-    row['timestamp'].should be_an_instance_of(Time)
-    row['decimal_test'].should be_an_instance_of(BigDecimal)
-    row['binary_test'].should be_an_instance_of(String)
-    
-    # verify that the row values were converted correctly
-    row.should == {
-      'id' => 1, 
-      'decimal_test' => BigDecimal.new("1.234"),
-      'timestamp' => Time.local(2007,"nov",10,20,15,1),
-      'binary_test' => Marshal.dump(['bla',:dummy,1,2,3])
-    }
-  end
-end

data/spec/uninstall_runner_spec.rb

@@ -1,93 +0,0 @@
-require File.dirname(__FILE__) + '/spec_helper.rb'
-
-include RR
-
-describe UninstallRunner do
-  before(:each) do
-  end
-
-  it "should register itself with CommandRunner" do
-    CommandRunner.commands['uninstall'][:command].should == UninstallRunner
-    CommandRunner.commands['uninstall'][: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 = UninstallRunner.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 = UninstallRunner.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 = UninstallRunner.new
-    status = runner.process_options ["--help"]
-    runner.options.should == nil
-    status.should == 0
-  end
-
-  it "process_options should set the correct options" do
-    runner = UninstallRunner.new
-    runner.process_options ["-c", "config_path"]
-    runner.options[:config_file].should == 'config_path'
-  end
-
-  it "run should not start an uninstall if the command line is invalid" do
-    $stderr.should_receive(:puts).any_number_of_times
-    UninstallRunner.any_instance_should_not_receive(:execute) {
-      UninstallRunner.run(["--nonsense"])
-    }
-  end
-
-  it "run should start an uninstall if the command line is correct" do
-    UninstallRunner.any_instance_should_receive(:execute) {
-      UninstallRunner.run(["--config=path"])
-    }
-  end
-
-  it "session should create and return the session" do
-    runner = UninstallRunner.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 "execute should uninstall all rubyrep elements" do
-    begin
-      org_stdout, $stdout = $stdout, StringIO.new
-      config = deep_copy(standard_config)
-      config.options[:rep_prefix] = 'rx'
-      session = Session.new(config)
-      initializer = ReplicationInitializer.new(session)
-
-      initializer.ensure_infrastructure
-      initializer.create_trigger :left, 'scanner_records'
-
-      runner = UninstallRunner.new
-      runner.stub!(:session).and_return(session)
-
-      runner.execute
-
-      initializer.trigger_exists?(:left, 'scanner_records').should be_false
-      initializer.change_log_exists?(:left).should be_false
-      session.right.tables.include?('rx_running_flags').should be_false
-      initializer.event_log_exists?.should be_false
-
-      $stdout.string =~ /uninstall completed/i
-    ensure
-      $stdout = org_stdout
-    end
-  end
-end

data/tasks/rubyrep.tailor

@@ -1,18 +0,0 @@
-[DEFAULT]
-verbose = True
-
-[project]
-target = svn:target
-start-revision = 1
-root-directory = /tmp/rubyrep_tailor
-state-file = tailor.state
-source = hg:source
-
-[hg:source]
-repository = .
-subdir = hg
-
-[svn:target]
-repository = file:///tmp/rubyrep_tailor/svn_repository
-module = rubyrep
-subdir = svn

data/tasks/website.rake

@@ -1,19 +0,0 @@
-namespace :website do
-  desc 'Generate website files'
-  task :generate => :ruby_env do
-    (Dir['website/**/*.txt'] - Dir['website/version*.txt']).each do |txt|
-      sh %{ #{RUBY_APP} script/txt2html #{txt} > #{txt.gsub(/txt$/,'html')} }
-    end
-  end
-
-  desc 'Upload website files to rubyforge'
-  task :upload do
-    host = "#{rubyforge_username}@rubyforge.org"
-    remote_dir = "/var/www/gforge-projects/#{RUBYFORGE_PROJECT}/"
-    local_dir = 'website'
-    sh %{rsync -aCv #{local_dir}/ #{host}:#{remote_dir}}
-  end
-
-  desc 'Generate and upload website files'
-  task :build => [:website_generate, :website_upload, :publish_docs]
-end