strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/sync/spec_helper.rb

@@ -0,0 +1 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))

data/spec/lib/strokedb/sync/store_sync_spec.rb

@@ -0,0 +1,181 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Store that syncs documents in" do
+
+  before(:each) do
+    FileUtils.rm_rf TEMP_STORAGES + '/store_sync'
+    FileUtils.rm_rf TEMP_STORAGES + '/store_sync_another'
+    StrokeDB::Config.build :default => true, :base_path => TEMP_STORAGES + '/store_sync'
+    @store = StrokeDB.default_store
+    another_cfg = StrokeDB::Config.build :base_path => TEMP_STORAGES + '/store_sync_another'
+    @another_store = another_cfg.stores[:default]
+  end
+
+  after(:each) do
+    @store.stop_autosync!
+    @another_store.stop_autosync!
+    FileUtils.rm_rf TEMP_STORAGES + '/store_sync'
+    FileUtils.rm_rf TEMP_STORAGES + '/store_sync_another'
+  end
+
+  it "should add document that does not yet exist" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    sync_rep = @store.sync!(doc.versions.all.reverse)
+    @store.find(doc.uuid,doc.previous_version).should == doc.versions.previous
+    @store.find(doc.uuid,doc.version).should == doc
+    @store.find(doc.uuid).should == doc
+    @store.find(doc.uuid).versions.all.should_not include(nil)
+    sync_rep.conflicts.should be_empty
+    sync_rep.fast_forwarded_documents.should be_empty
+    sync_rep.added_documents.should == [doc]
+  end
+
+  it "should fast-forward document if applicable" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    sync_rep = @store.sync!(doc.versions.all.reverse)
+    doc_at_store = @store.find(doc.uuid)
+    sync_rep.conflicts.should be_empty
+    sync_rep.added_documents.should == [doc_at_store]
+    sync_rep.fast_forwarded_documents.should be_empty
+    doc_at_store.ok = true
+    doc_at_store.save!
+    another_sync_rep = @another_store.sync!(doc_at_store.versions.all.reverse)
+    doc = @another_store.find(doc_at_store.uuid)
+    doc.should == doc_at_store
+    another_sync_rep.conflicts.should be_empty
+    another_sync_rep.added_documents.should be_empty
+    another_sync_rep.fast_forwarded_documents.should == [doc]
+  end
+
+  it "should create non-matching report if applicable" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    adoc = Document.create!(:uuid => doc.uuid, :world => 'hello')
+    sync_rep = @store.sync!(doc.versions.all.reverse)
+    sync_rep.conflicts.should be_empty
+    sync_rep.non_matching_documents.should == [adoc]
+    sync_rep.added_documents.should be_empty
+    sync_rep.fast_forwarded_documents.should be_empty
+  end
+
+  it "should do nothing if everything is up-to-date" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    sync_rep = @store.sync!(doc.versions.all.reverse)
+    sync_rep.conflicts.should be_empty
+    sync_rep.non_matching_documents.should be_empty
+    sync_rep.added_documents.should_not be_empty
+    sync_rep.fast_forwarded_documents.should be_empty
+    doc_at_store = @store.find(doc.uuid)
+    another_sync_rep = @another_store.sync!(doc_at_store.versions.all.reverse)
+    @another_store.find(doc_at_store.uuid).should == doc_at_store
+    another_sync_rep.conflicts.should be_empty
+    another_sync_rep.non_matching_documents.should be_empty
+    another_sync_rep.added_documents.should be_empty
+    another_sync_rep.fast_forwarded_documents.should be_empty
+  end
+
+  it "should create SynchronizationConflict if applicable" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    @store.sync!(doc.versions.all.reverse)
+    doc_at_store = @store.find(doc.uuid)
+    doc_at_store.ok = true
+    doc_at_store.save!
+    doc.ok = false
+    doc.save!
+    another_sync_rep = @another_store.sync!(doc_at_store.versions.all.reverse)
+    another_sync_rep.non_matching_documents.should be_empty
+    another_sync_rep.added_documents.should be_empty
+    another_sync_rep.fast_forwarded_documents.should be_empty
+    another_sync_rep.conflicts.should_not be_empty
+    conflict = another_sync_rep.conflicts.first
+    conflict.rev1[0].should == doc_at_store.version
+    conflict.rev2[0].should == doc.version
+  end
+
+  it "should try to resolve SynchronizationConflict if it was created" do
+    doc = Document.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    @store.sync!(doc.versions.all.reverse)
+    doc_at_store = @store.find(doc.uuid)
+    doc_at_store.ok = true
+    doc_at_store.save!
+    doc.ok = false
+    doc.save!
+    resolve_called = 0
+    SynchronizationConflict.module_eval do
+      define_method('resolve!') do
+        resolve_called += 1
+      end
+    end
+    another_sync_rep = @another_store.sync!(doc_at_store.versions.all.reverse)
+    resolve_called.should == 1
+  end
+
+  it "should add resolution meta to SynchronizationConflict document if it is specified in synchronized document" do
+    Object.send!(:remove_const,'SomeStrategy') if defined?(SomeStrategy)
+    SomeStrategy = Meta.new
+
+    Object.send!(:remove_const,'SomeMeta') if defined?(SomeMeta)
+    SomeMeta = Meta.new(:resolution_strategy => SomeStrategy)
+
+    # ensure that all metas exist in both stores
+    SomeStrategy.document
+    SomeMeta.document
+    @another_store.sync!(SomeStrategy.document.versions.all.reverse+SomeMeta.document.versions.all.reverse,@store.timestamp)
+
+    doc = SomeMeta.create!(@another_store, :hello => 'world')
+    doc.test = 'passed'
+    doc.save!
+    @store.sync!(doc.versions.all.reverse)
+    doc_at_store = @store.find(doc.uuid)
+    doc_at_store.ok = true
+    doc_at_store.save!
+    doc.ok = false
+    doc.save!
+
+    some_strategy_resolve = 0
+    SomeStrategy.module_eval do
+      define_method("resolve!") do
+        some_strategy_resolve += 1
+      end
+    end
+
+    another_sync_rep = @another_store.sync!(doc_at_store.versions.all.reverse)
+    conflict = another_sync_rep.conflicts.first
+    conflict.should be_a_kind_of(SomeStrategy)
+    some_strategy_resolve.should == 1
+  end
+
+  it "should store original timestamp in synchronization report" do
+    original_timestamp = @store.timestamp.counter
+    sync_rep = @store.sync!([])
+    sync_rep.timestamp.should == original_timestamp
+  end
+
+  it "should store store's document in synchronization report" do
+    sync_rep = @store.sync!([])
+    sync_rep.store_document.should == @store.document
+  end
+
+  it "should update timestamp prior to.sync! if it is specified" do
+    original_timestamp = @store.timestamp
+    @store.sync!([],100)
+    @store.timestamp.counter.should >= 100
+    @store.timestamp.should_not == original_timestamp
+    original_timestamp = @store.timestamp
+    @store.sync!([],LTS.new(200))
+    @store.timestamp.counter.should >= 200
+    @store.timestamp.should_not == original_timestamp
+  end
+
+end

data/spec/lib/strokedb/sync/stroke_diff/array_spec.rb

@@ -0,0 +1,97 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Array diff" do
+  
+  before(:each) do
+    @arr = [1, 2]
+    @obj = Object.new
+  end
+  
+  it "should correctly patch array with array diff" do
+    2000.times {
+      from = gen_str.split(//u)
+      to   = gen_str.split(//u)
+      from.stroke_patch(from.stroke_diff(to)).should == to
+    }
+  end
+  
+  [ nil,
+    1, 2**64, -1.0,
+    :sym,
+    "string",
+    {:arr => 1},
+    @obj
+  ].each do |obj|
+    it "should correctly patch array with a replacement #{obj.inspect}" do
+      @arr.stroke_patch(@arr.stroke_diff(obj)).should == obj
+    end
+  end
+  
+  it "should correctly patch array with objects" do
+    arr = (1..10).to_a.map{ Object.new }
+    a = [arr[0], arr[2], arr[3], arr[4], arr[8]]
+    b = [arr[1], arr[2], arr[3], arr[8], arr[9], arr[4], arr[1]]
+    a.stroke_patch(a.stroke_diff(b)).should == b
+  end
+  
+  def gen_str
+    letters = %w(a b c d)
+    str = ""
+    len = rand(letters.size*2)
+    len.times {
+      str << letters[rand(letters.size)]
+    }
+    str
+  end
+end
+
+describe "Automerging arrays" do
+  
+  before(:each) do
+    @base = [1, 2, 3]
+  end
+  
+  it "should do a trivial one-side merge" do
+    a = [1, 2, 3]
+    b = [1, 2, 4, 3]
+    should_merge(@base, a, b, [1, 2, 4, 3])
+  end
+
+  it "should do a trivial two-side merge" do
+    a = [   1, 2, 3, 4]
+    b = [0, 1, 2, 3   ]
+    should_merge(@base, a, b, [0, 1, 2, 3, 4])
+    
+    a = [       1, 2, 3, 4, 5]
+    b = [-1, 0, 1, 2, 3   ]
+    should_merge(@base, a, b, [-1, 0, 1, 2, 3, 4, 5])
+  end
+  
+  it "should do a trivial merge with missing elements" do
+    a = [   1, 2, 4]
+    b = [0, 1, 2, 3]
+    should_merge(@base, a, b, [0, 1, 2, 4])
+  end
+  
+  # it "should merge same slot deletion" do
+  #   should_merge({:a => 1, :b => 2}, {:b => 2}, {:b => 3}, {:b => 3})
+  #   should_merge({:a => 1, :b => 2}, {:b => 2}, {:b => 2}, {:b => 2})
+  # end
+  # 
+  # it "should merge when one of the objects is the same" do
+  #   bases = [{:a => 1}, {:a => 1, :b => 2}, {:a => 1, :b => 2}]
+  #   bs    = [{:a => 3}, {:a => 1}, {:b => "22"}, nil, 123, Object.new, :symb, false, true]
+  #   
+  #   bases.each do |base|
+  #     bs.each do |b|
+  #       should_merge(base, base, b, b)
+  #     end
+  #   end
+  # end
+  
+  
+end
+
+
+
+

data/spec/lib/strokedb/sync/stroke_diff/complex_spec.rb

@@ -0,0 +1,58 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Complex diff" do
+  objs = [
+    [1,2,"str"]
+  ]
+  it "should patch scalar" do
+    1000.times do 
+      a = gen_complex_object
+      b = gen_complex_object
+      unless a.stroke_patch(a.stroke_diff(b)) == b
+        puts ""
+        puts "a = #{a.inspect}"
+        puts "b = #{b.inspect}"
+        puts "a.stroke_diff(b)"
+        puts "a.stroke_patch(a.stroke_diff(b))"
+      end
+      a.stroke_patch(a.stroke_diff(b)).should == b
+    end
+  end
+  
+  def gen_complex_object
+    scalars = [1, :sym, false, true, nil, :hash, :array, :string]
+    s = scalars[rand(scalars.size)]
+    case s
+    when :hash
+      gen_hash
+    when :array
+      gen_array
+    when :string
+      gen_string
+    else
+      s
+    end
+  end
+  
+  def gen_hash
+    keys = gen_string.split(//u)
+    keys.inject({}) do |h, k|
+      h[k] = gen_complex_object
+      h
+    end
+  end
+
+  def gen_array
+    len = rand(4*2)
+    (1..len).to_a.map{ gen_complex_object }
+  end
+  
+  def gen_string
+    letters = %w(a b c d)
+    (1..rand(letters.size*2)).inject("") { |s, l|
+      s << letters[rand(letters.size)]
+      s
+    }
+  end
+  
+end

data/spec/lib/strokedb/sync/stroke_diff/hash_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Hash diff" do
+  
+  before(:each) do
+    @hash = {:a => 1}
+    @obj = Object.new
+  end
+  
+  it "should correctly patch hash with hash diff" do
+    2000.times {
+      from = Hash[*(gen_str.split(//u)*2)]
+      to   = Hash[*(gen_str.split(//u)*2)]
+      from.stroke_patch(from.stroke_diff(to)).should == to
+    }
+  end
+  
+  [ nil,
+    1, 2**64, -1.0,
+    :sym,
+    "string",
+    [:arr, 1],
+    @obj
+  ].each do |obj|
+    it "should correctly patch hash with a replacement #{obj.inspect}" do
+      @arr.stroke_patch(@arr.stroke_diff(obj)).should == obj
+    end
+  end
+  
+  it "should correctly patch hash with objects" do
+    arr = (1..10).to_a.map{ Object.new }
+    a = Hash[1, arr[0], 2, arr[2], 3, arr[3], 4, arr[4], 5, arr[8]]
+    b = Hash[1, arr[1], 2, arr[2], 3, arr[3], 4, arr[8], 5, arr[9], 6, arr[4], 7, arr[1]]
+    a.stroke_patch(a.stroke_diff(b)).should == b
+  end
+  
+  def gen_str
+    letters = %w(a b c d)
+    str = ""
+    len = rand(letters.size*2)
+    len.times {
+      str << letters[rand(letters.size)]
+    }
+    str
+  end
+end
+
+describe "Automerging hashes" do
+  
+  before(:each) do
+    @base = {:a => 1, :b => 2, :c =>3}
+  end
+  
+  it "should do a trivial merge" do
+    a = @base.merge :a => 2, :x => 1
+    b = @base.merge :b => 3, :y => 2
+    should_merge(@base, a, b, @base.merge(:a => 2, :x => 1, :b => 3, :y => 2))
+  end
+  
+  it "should do a trivial merge with missing slots" do
+    b1 = @base.dup; b1.delete(:a)
+    b2 = @base.dup; b2.delete(:b)
+    a = b1.merge :x => 2
+    b = b2.merge :y => 3
+    should_merge(@base, a, b, {:c => @base[:c], :x => 2, :y => 3})
+  end
+  
+  it "should merge intersecting, but identical old slots" do
+    a = @base.merge :a => 2, :c => 42
+    b = @base.merge :b => 3, :c => 42
+    should_merge(@base, a, b, @base.merge(:a => 2, :b => 3, :c => 42))
+  end
+  
+  it "should merge intersecting, but identical new slots" do
+    a = @base.merge :a => 2, :x => 42
+    b = @base.merge :b => 3, :x => 42
+    should_merge(@base, a, b, @base.merge(:a => 2, :b => 3, :x => 42))
+  end
+  
+  it "should merge deep diffed slots" do
+    base = {:s => { :a => 1 }}
+    a    = {:s => { :a => 2 }}
+    b    = {:s => { :a => 1, :b => 3 }}
+    should_merge(base, a, b, {:s => { :a => 2, :b => 3 }})
+  end
+  
+  it "should merge same slot deletion" do
+    should_merge({:a => 1, :b => 2}, {:b => 2}, {:b => 3}, {:b => 3})
+    should_merge({:a => 1, :b => 2}, {:b => 2}, {:b => 2}, {:b => 2})
+  end
+  
+  it "should merge when one of the objects is the same" do
+    bases = [{:a => 1}, {:a => 1, :b => 2}, {:a => 1, :b => 2}]
+    bs    = [{:a => 3}, {:a => 1}, {:b => "22"}, nil, 123, Object.new, :symb, false, true]
+    
+    bases.each do |base|
+      bs.each do |b|
+        should_merge(base, base, b, b)
+      end
+    end
+  end
+end
+
+describe "Merge conflicts in hashes" do
+  
+  it "should yield a diff-diff conflict with partial merge" do
+    base = {:a => 1,   :b => 2,   :c =>3}
+    a    = {:a => 111, :b => 222, :c =>3}
+    b    = {:a => 222, :b => 2,   :c =>333}
+    ra   = {:a => 111, :b => 222, :c =>333}
+    rb   = {:a => 222, :b => 222, :c =>333}
+    should_yield_conflict(base, a, b, ra, rb)
+  end
+    
+  it "should yield a deletion-diff conflict with partial merge" do
+    base = {:a => 1,   :b => 2,   :c =>3}
+    a    = {           :b => 222, :c =>3}
+    b    = {:a => 222, :b => 2,   :c =>333}
+    ra   = {           :b => 222, :c =>333}
+    rb   = {:a => 222, :b => 222, :c =>333}
+    should_yield_conflict(base, a, b, ra, rb)
+  end
+  
+  it "should yield a insertion-insertion conflict with partial merge" do
+    base = {           :b => 2,   :c =>3}
+    a    = {:a => 111, :b => 222, :c =>3}
+    b    = {:a => 222, :b => 2,   :c =>333}
+    ra   = {:a => 111, :b => 222, :c =>333}
+    rb   = {:a => 222, :b => 222, :c =>333}
+    should_yield_conflict(base, a, b, ra, rb)
+  end
+  
+  it "should yield a deep diff-diff conflict with partial merge" do
+    base = {:s => { :a => 1, :b => 2,  :c => 3  }, :del => 1 }
+    a    = {:s => { :a => 2, :b => 22, :c => 3  }, :del => 1, :x => 1 }
+    b    = {:s => { :a => 3, :b => 2,  :c => 33 }}
+    ra   = {:s => { :a => 2, :b => 22, :c => 33 }, :x => 1}
+    rb   = {:s => { :a => 3, :b => 22, :c => 33 }, :x => 1}
+    should_yield_conflict(base, a, b, ra, rb)
+  end
+end
+
+
+