strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/stores/transaction_spec.rb

@@ -0,0 +1,107 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe 'Transaction', :shared => true do
+
+  it "should have UUID" do
+    @txn.uuid.should match(/#{UUID_RE}/)
+  end
+  
+  it "should act as a store for documents initialized within transaction scope" do
+    @txn.execute do
+      @doc = Document.new
+      @doc.store.should == @txn
+    end
+  end
+  
+  it "should revert newly instantiated documents' store to main one outside of transaction scope" do
+    @txn.execute do
+      @doc = Document.new
+    end
+    @doc.store.should == @txn.store
+  end
+  
+  it "should acts as a store for already initialized documents" do
+    @doc = Document.new
+    @txn.execute do
+      @doc.store.should == @txn
+    end
+  end
+  
+  it "should return block result on block execution" do
+    @txn.execute do
+      :some_result
+    end.should == :some_result
+  end
+
+  it "should be able to find already existing document within transaction scope" do
+    @doc = Document.create!
+    @txn.execute do
+      Document.find(@doc.uuid).should == @doc
+    end
+  end
+  
+  it "should be able to save new documents within block execution without exposing them to original storage" do
+    @txn.execute do
+      @doc = Document.create!
+      Document.find(@doc.uuid).should == @doc
+    end
+    Document.find(@doc.uuid).should be_nil
+  end
+  
+  it "should see its own head version of the document" do
+    @doc = Document.create!
+    @txn.execute do |txn|
+      @doc.update_slots! :new_version => 'yes'
+      @doc.store.head_version(@doc.uuid).should == @doc.version
+    end
+    @doc.store.head_version(@doc.uuid).should == @doc.versions.previous.version
+  end
+
+  it "should be able to commit transaction" do
+    @txn.execute do |txn|
+      @doc = Document.create!
+      txn.commit!
+    end
+    Document.find(@doc.uuid).should == @doc
+  end
+
+  it "should be able to rollback transaction" do
+    @txn.execute do |txn|
+      @doc = Document.create!
+      txn.rollback!
+      Document.find(@doc.uuid).should be_nil
+    end
+    Document.find(@doc.uuid).should be_nil
+  end
+  
+  it "should pop transaction on code that raises some exception" do
+    lambda do
+      @txn.execute do |txn|
+        raise Exception
+      end
+    end.should raise_error(Exception)
+    Thread.current[:strokedb_transactions].should be_empty
+  end
+
+  it "should pop transaction on code that raises no exception" do
+    lambda do
+      @txn.execute do |txn|
+      end
+    end.should_not raise_error(Exception)
+    Thread.current[:strokedb_transactions].should be_empty
+  end
+  
+    
+end
+
+describe "New", Transaction do
+  
+  before(:each) do
+    StrokeDB::Config.build :default => true, :storages => [:memory], :base_path => TEMP_STORAGES + '/txn'
+    @txn = Transaction.new(:store => StrokeDB.default_store)
+    Thread.current[:strokedb_transactions] = nil
+  end
+  
+  it_should_behave_like 'Transaction'
+  
+end

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

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Chain sync" do
+  include ChainSync
+  before(:each) do
+    @chain1 = %w[ a b c     ]
+    @chain2 = %w[ a b c d e ]
+    @chain3 = %w[ a b q w r ]
+    @chain4 = %w[ t y u i o ]
+  end
+  
+  it "should raise NonMatchingChains for non-matching chains" do
+    lambda{ sync_chains(@chain1, @chain4) }.should raise_error(ChainSync::NonMatchingChains)
+    lambda{ sync_chains(@chain4, @chain1) }.should raise_error(ChainSync::NonMatchingChains)
+  end
+  
+  it "should not raise NonMatchingChains for matching chains" do
+    lambda{ sync_chains(@chain1, @chain2) }.should_not raise_error
+    lambda{ sync_chains(@chain1, @chain3) }.should_not raise_error
+    lambda{ sync_chains(@chain2, @chain3) }.should_not raise_error
+    lambda{ sync_chains(@chain2, @chain1) }.should_not raise_error
+    lambda{ sync_chains(@chain3, @chain1) }.should_not raise_error
+    lambda{ sync_chains(@chain3, @chain2) }.should_not raise_error
+  end
+
+  it "should resolve up-to-date situation" do
+    sync_chains(@chain1, @chain2).should == :up_to_date
+    sync_chains(@chain2, @chain1).should_not == :up_to_date
+  end
+  
+  it "should resolve fast-forward situation" do
+    status, subchain = sync_chains(@chain2, @chain1)
+    status.should == :fast_forward
+    subchain.should == %w[ c d e ]
+  end
+  
+  it "should resolve merge situation" do
+    status, subchain_from, subchain_to = sync_chains(@chain2, @chain3)
+    status.should == :merge
+    subchain_from.should == %w[ b c d e ]
+    subchain_to.should   == %w[ b q w r ]
+  end
+end

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

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Diffing documents", :shared => true do
+  it "should have from and to specified" do
+    [:from,:to].each do |slotname|
+      @diff[slotname].should be_a_kind_of(Document)
+    end
+  end
+
+  it "should be appliable as patch" do
+    from = @from.dup
+    @diff.patch!(from)
+    (from.slotnames - ['version','previous_version']).should == (@to.slotnames-['version','previous_version'])
+    (from.slotnames - ['version','previous_version']).each do |slotname|
+      from[slotname].should == @to[slotname]
+    end
+  end
+end
+
+describe "Diffing documents with slot added" do
+  before(:each) do
+    @store = setup_default_store
+    @from = Document.create! :slot1 => 1
+    @to = Document.create! :slot1 => 1, :slot2 => 2
+    @diff = @to.diff(@from)
+  end
+
+  it "should list added slot" do
+    @diff.added_slots.keys.to_set.should == ['slot2'].to_set
+    @diff.added_slots['slot2'].should == 2
+  end
+
+  
+  it "should report as modified" do
+    @diff.should be_different
+  end
+
+  it_should_behave_like "Diffing documents"
+
+end
+
+describe "Diffing documents with slot removed" do
+  before(:each) do
+    @store = setup_default_store
+    @from = Document.create! :slot1 => 1, :slot2 => 2
+    @to = Document.create! :slot1 => 1
+    @diff = @to.diff(@from)
+  end
+
+  it "should list removed slot" do
+    @diff.removed_slots.keys.to_set.should == ['slot2'].to_set
+    @diff.removed_slots['slot2'].should == 2
+  end
+  
+
+  it "should report as modified" do
+    @diff.should be_different
+  end
+
+  it_should_behave_like "Diffing documents"
+
+
+end
+
+describe "Diffing documents with slot changed" do
+  before(:each) do
+    @store = setup_default_store
+    @from = Document.create! :slot1 => 1
+    @to = Document.create! :slot1 => 2
+    @diff = @to.diff(@from)
+  end
+
+  it "should list updated slot" do
+    @diff.updated_slots.keys.to_set.should == ['slot1','uuid'].to_set
+    @diff.updated_slots['slot1'].should == 2
+  end
+  
+
+  it "should report as modified" do
+    @diff.should be_different
+  end
+  
+
+  it_should_behave_like "Diffing documents"
+
+end
+
+
+['slot_1_diff','default_slot_diff'].each do |strategy|
+  describe "Diffing documents with slot changed with slot diffing strategy" do
+    before(:each) do
+      @store = setup_default_store
+      
+      Object.send!(:remove_const,'Slot1Diff') if defined?(Slot1Diff)
+      Slot1Diff = Class.new(SlotDiffStrategy)
+      Slot1Diff.should_receive(:diff).with("abcdef","abcdef1").any_number_of_times.and_return("1")
+      Slot1Diff.should_receive(:patch).with("abcdef","1").any_number_of_times.and_return("abcdef1")
+      
+
+      @meta = Document.create! :diff_strategy_slot1 => strategy # TODO: fix this spec, it willn't care if I say strategy_slot1
+
+      @from = Document.create! :slot1 => "abcdef", :meta => @meta
+      @to = Document.create! :slot1 => "abcdef1", :meta => @meta
+
+      @diff = @to.diff(@from)
+    end
+
+    it_should_behave_like "Diffing documents"
+
+  end
+end

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

@@ -0,0 +1,174 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "LamportTimestamp" do
+  it "#zero_string" do
+    LamportTimestamp.zero_string.should == '000000000000000000000000-0000-0000-0000-000000000000'
+  end
+end
+
+describe "Initial LamportTimestamp" do
+  before(:each) do
+    @t0 = LamportTimestamp.new
+  end
+
+  it "should have counter == 0" do
+    @t0.counter.should == 0
+  end
+
+  it "should have UUID-based uuid" do
+    @t0.uuid.should match(UUID_RE)
+  end
+
+  it "should pass generated uuid on #next" do
+    @t0.next.uuid.should == @t0.uuid
+  end
+  
+  it "shoul return marshal_dump as json" do
+    @t0.to_json.should == '"0000000000000000'+@t0.uuid+'"'
+  end
+end
+
+
+describe "Initial LamportTimestamp with uuid specified" do
+  before(:each) do
+    @t0   = LamportTimestamp.new(0,NIL_UUID)
+  end
+
+  it "should have counter == 0" do
+    @t0.counter.should == 0
+  end
+
+  it "should have UUID-based uuid as defined" do
+    @t0.uuid.should == NIL_UUID
+  end
+
+  it "should pass uuid on #next" do
+    @t0.next.uuid.should == @t0.uuid
+  end
+end
+
+
+describe "Preset LamportTimestamp" do
+  before(:each) do
+    @t0   = LamportTimestamp.new()
+    @t123 = LamportTimestamp.new(123)
+    @t234 = LamportTimestamp.new(234)
+  end
+
+  it "should be compared properly" do
+    (@t0   <=> @t123).should  == -1
+    (@t123 <=> @t234).should  == -1
+  end
+
+  it "should have UUID-based uuid" do
+    @t123.uuid.should match(UUID_RE)
+    @t234.uuid.should match(UUID_RE)
+  end
+end
+
+
+describe "LamportTimestamp equality" do
+  before(:each) do
+    @t = LamportTimestamp.new(123)
+    @t_dumped = Marshal.dump(@t)
+    @t_loaded = Marshal.load(@t_dumped)
+  end
+
+  # Positive
+  it { @t.should == @t }
+  it { @t.should == @t_loaded }
+  it "should correctly compare tons of dumped-loaded timestamps" do
+    1000.times do
+      t = LamportTimestamp.new(rand(2**64))
+      t.should == Marshal.load(Marshal.dump(t))
+    end
+  end
+
+  # Negative
+  it { LamportTimestamp.new().should_not == LamportTimestamp.new() }
+  it { LamportTimestamp.new(123).should_not == LamportTimestamp.new(123) }
+  it { LamportTimestamp.new(234).should_not == LamportTimestamp.new(234) }
+end
+
+
+describe "Lesser and greater LamportTimestamps" do
+  before(:each) do
+    @t0   = LamportTimestamp.new()
+    @t123 = LamportTimestamp.new(123)
+  end
+
+  it "should be comparable with <" do
+    @t0.should < @t123
+    @t123.should_not < @t0
+  end
+
+  it "should be comparable with <=" do
+    @t0.should <= @t123
+    @t123.should <= @t123
+    @t123.should_not <= @t0
+  end
+
+  it "should be comparable with >" do
+    @t123.should > @t0
+    @t123.should_not > @t123
+    @t0.should_not > @t123
+  end
+
+  it "should be comparable with >=" do
+    @t123.should >= @t0
+    @t123.should >= @t123
+    @t0.should_not >= @t123
+  end
+
+  it { 1000.times { t = LamportTimestamp.new(rand(2**64)); t.next.next.should > t.next } }
+
+  it "should generate a list of successive timestamps with next!" do 
+    t = LamportTimestamp.new(rand(2**32))
+    1000.times do
+      t_ = t.dup
+      t.next!
+      t_.should < t
+      t_.uuid.should == t.uuid
+    end 
+  end
+end
+
+
+describe "LamportTimestamp maximum counter exception" do
+  it "should raise error if counter is too big" do
+    lambda { LamportTimestamp.new(2**64 + 1) }.should raise_error(LamportTimestamp::CounterOverflow)
+  end
+  it "should not raise error if counter is 2**64" do
+    lambda { LamportTimestamp.new(2**64) }.should_not raise_error
+    lambda { LamportTimestamp.new(2**64-1) }.should_not raise_error
+  end
+  it "should raise error on LamportTimestamp#next" do
+    lambda { LamportTimestamp.new(2**64).next }.should raise_error(LamportTimestamp::CounterOverflow)
+  end
+  it "should not raise error on LamportTimestamp#next if no overflow occured" do
+    lambda { LamportTimestamp.new(2**64 - 1).next }.should_not raise_error
+  end
+end
+
+
+describe "LamportTimestamp raw format" do
+  before(:each) do
+    @t = LamportTimestamp.new(123)
+  end
+  it "should convert to simple string" do
+    @t.to_raw.should == @t.to_s
+  end
+  it "should correctly convert end-to-end" do
+    LamportTimestamp.from_raw(@t.to_raw).should == @t 
+  end
+  it "should compare raw representation exactly like object representation" do
+    1000.times do
+      t1 = LTS.new(rand(2**32))
+      t2 = LTS.new(rand(2**32))
+      object_comparison = (t1 <=> t2)
+      raw_comparison = (t1.to_raw <=> t2.to_raw)
+      object_comparison.should == raw_comparison
+    end
+  end
+end
+

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

@@ -0,0 +1,164 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Diffing documents with slot changed and slot's diff strategy is specified on meta" do
+
+  before(:each) do
+    @store = setup_default_store
+    Object.send!(:remove_const,'Slot1Diff') if defined?(Slot1Diff)
+    Slot1Diff = Class.new(SlotDiffStrategy)
+    Slot1Diff.should_receive(:diff).with(1,2).and_return(3)
+
+    @meta = Document.create! :diff_strategy_slot1 => 'slot_1_diff'
+
+    @from = Document.create! :slot1 => 1, :meta => @meta
+    @to = Document.create! :slot1 => 2, :meta => @meta
+
+    @diff = @to.diff(@from)
+  end
+
+  it "should diff slot value according to its strategy" do
+    @diff.updated_slots['slot1'].should == 3
+  end
+
+end
+
+
+describe "Diffing documents with slot changed and slot's diff strategy is specified on meta, but there is no such diff strategy" do
+
+  before(:each) do
+    @store = setup_default_store
+
+    Object.send!(:remove_const,'Slot1Diff') if defined?(Slot1Diff)
+    @meta = Document.create! :diff_strategy_slot1 => 'slot_1_diff'
+
+    @from = Document.create! :slot1 => 1, :meta => @meta
+    @to = Document.create! :slot1 => 2, :meta => @meta
+    
+    @diff = @to.diff(@from)
+  end
+
+  it "should not diff slot" do
+    @diff.updated_slots['slot1'].should == 2
+  end
+
+end
+
+describe "Diffing documents with slot changed and slot's diff strategy is specified on meta, but diff strategy is invalid" do
+
+  before(:each) do
+    @store = setup_default_store
+    Object.send!(:remove_const,'Slot1Diff') if defined?(Slot1Diff)
+
+    Slot1Diff = Class.new
+
+    @meta = Document.create! :diff_strategy_slot1 => 'slot_1_diff'
+
+    @from = Document.create! :slot1 => 1, :meta => @meta
+    @to = Document.create! :slot1 => 2, :meta => @meta
+    
+    @diff = @to.diff(@from)
+  end
+
+  it "should not diff slot" do
+    @diff.updated_slots['slot1'].should == 2
+  end
+
+end
+
+[DefaultSlotDiff].each do |strategy|
+  
+  describe "#{strategy.name} for String" do
+    before(:each) do
+      @string1 = "hello world"
+      @string2 = "bye world"
+    end
+    
+    it "should diff to an LCS structure" do
+      strategy.diff(@string1, @string2).should be_a_kind_of(Array)
+    end
+    
+    it "should patch String back" do
+      strategy.patch(@string1,strategy.diff(@string1, @string2)).should == @string2
+    end
+
+  end
+  
+  describe "#{strategy.name} for Array" do
+    before(:each) do
+      @array1 = [1,2,3]
+      @array2 = [1,5,3]
+    end
+    
+    it "should diff to an LCS structure" do
+      strategy.diff(@array1, @array2).should be_a_kind_of(Array)
+    end
+    
+    it "should patch Array back" do
+      strategy.patch(@array1,strategy.diff(@array1, @array2)).should == @array2
+    end
+  end
+
+  describe "#{strategy.name} for Hash" do
+    before(:each) do
+      @hash1 = { :a => 1}
+      @hash2 = { :a => 1, :b => 2}
+    end
+    
+    it "should diff to an LCS structure" do
+      strategy.diff(@hash1, @hash2).should be_a_kind_of(Array)
+    end
+    
+    it "should patch Hash back" do
+      strategy.patch(@hash1,strategy.diff(@hash1, @hash2)).should == @hash2
+    end
+  end  
+  
+  
+  describe "#{strategy.name} for document reference" do
+    before(:each) do
+      @ref1 = "@##{Util.random_uuid}"
+      @ref2 = "@##{Util.random_uuid}"
+    end
+    
+    it "should diff to an LCS structure" do
+      strategy.diff(@ref1, @ref2).should be_a_kind_of(String)
+    end
+    
+    it "should patch document reference back" do
+      strategy.patch(@ref1,strategy.diff(@ref1, @ref2)).should == @ref2
+    end
+  end  
+  
+  
+  
+  describe "#{strategy.name} for number" do
+    before(:each) do
+      @num1 = 1
+      @num2 = 2
+    end
+    
+    it "should diff to an LCS structure" do
+      strategy.diff(@num1, @num2).should be_a_kind_of(Numeric)
+    end
+    
+    it "should patch number back" do
+      strategy.patch(@num1,strategy.diff(@num1, @num2)).should == @num2
+    end
+  end
+  
+  describe "#{strategy.name} for different types" do
+    before(:each) do
+      @val1 = 1
+      @val2 = "a"
+    end
+    
+    it "should diff to target value" do
+      strategy.diff(@val1, @val2).should == @val2
+    end
+    
+    it "should patch number back" do
+      strategy.patch(@val1,strategy.diff(@val1, @val2)).should == @val2
+    end
+
+  end
+end