strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/document/virtualize_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+def setup
+  setup_default_store
+  setup_index
+  Object.send!(:remove_const, 'Foo') if defined? Foo
+  Object.send!(:remove_const, 'Bar') if defined? Bar
+end
+
+describe "Document slot virtualization" do
+  before :each do
+    setup
+
+    Foo = Meta.new do 
+      virtualizes [ :virtual_slot, :another_slot ]
+    end
+  end
+
+  it "should act like a slot" do
+    f = Foo.new(:virtual_slot => 123)
+    f.virtual_slot.should == 123
+  end
+
+  it "should retain its value after save" do
+    f = Foo.new(:virtual_slot => 123, :another_slot => 456)
+    f.virtual_slot.should == 123
+    f.another_slot.should == 456
+    f.save!
+    f.virtual_slot.should == 123
+    f.another_slot.should == 456
+  end
+
+  it "should not serialize slot value" do
+    f = Foo.create!(:virtual_slot => 123)
+
+    f_copy = Foo.find(f.uuid)
+    f_copy.has_slot?("virtual_slot").should_not be_true
+  end
+  
+  it "should preserve version after saving document" do
+    f = Foo.new(:virtual_slot => 123)
+    lambda do
+      f.save!
+    end.should_not change(f,:version)
+  end
+
+  it "should preserve previous version after saving document" do
+    f = Foo.new(:virtual_slot => 123)
+    lambda do
+      f.save!
+    end.should_not change(f,:previous_version)
+  end
+
+  it "should allow to validate the virtual slot" do
+    Bar = Meta.new do
+      virtualizes :mylovelyslot
+      validates_presence_of :mylovelyslot
+    end
+
+    b = Bar.new(:mylovelyslot => 456)
+    b.should be_valid
+    lambda { b.save! }.should_not raise_error(InvalidDocumentError)
+  end
+
+  it "shouldn't restore virtual slot with :restore set to false" do
+    Bar = Meta.new { virtualizes :mylovelyslot, :restore => false }
+    b = Bar.new(:mylovelyslot => "abc")
+    b.mylovelyslot.should == "abc"
+    b.save!
+    b.has_slot?(:mylovelyslot).should be_false
+  end
+  
+  it "should preserve version after saving document with :restore set to false" do
+    Bar = Meta.new { virtualizes :mylovelyslot, :restore => false }
+    b = Bar.new(:mylovelyslot => "abc")
+    lambda do
+      b.save!
+    end.should_not change(b,:version)
+  end
+end

data/spec/lib/strokedb/nsurl_spec.rb

@@ -0,0 +1,73 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Some", Module do
+  
+  before(:each) do
+    @module = Module.new
+    Module.reset_nsurls
+  end
+  
+  after(:each) do
+    Module.reset_nsurls
+  end
+  
+  it "should have nil nsurl by default" do
+    @module.nsurl.should be_nil
+  end
+  
+  it "should be able to change nsurl" do
+    @module.nsurl 'http://some.url'
+    @module.nsurl.should == 'http://some.url'
+  end
+  
+  it "should be findable by nsurl" do
+    @module.nsurl 'http://some.url'
+    Module.find_by_nsurl(@module.nsurl).should == @module
+  end
+  
+  it "should be able to change nsurl to the same value" do
+    @module.nsurl 'http://some.url'
+    lambda { @module.nsurl 'http://some.url' }.should_not raise_error(ArgumentError)
+  end
+
+  it "should not be able to change nsurl to the value already assigned to some module" do
+    @some_module = Module.new
+    @some_module.nsurl 'http://some.url'
+    lambda { @module.nsurl 'http://some.url' }.should raise_error(ArgumentError)
+  end
+  
+end
+
+describe Module do
+  
+  
+  before(:each) do
+    Module.reset_nsurls
+  end
+  
+  after(:each) do
+    Module.reset_nsurls
+  end
+
+  
+  it "should have empty nsurl by default" do
+    Module.nsurl.should be_empty
+  end
+  
+end
+
+describe StrokeDB do
+  
+  before(:each) do
+    Module.reset_nsurls
+  end
+
+  after(:each) do
+    Module.reset_nsurls
+  end
+  
+  it "should have #{STROKEDB_NSURL} nsurl by default" do
+    StrokeDB.nsurl.should == STROKEDB_NSURL
+  end
+  
+end

data/spec/lib/strokedb/spec_helper.rb

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

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

@@ -0,0 +1,116 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+[ FileStorage, MemoryStorage ].each do |storage|
+  describe "Chained chunk storage (#{storage})" do
+
+    before(:each) do
+      @path = TEMP_STORAGES + '/file_chunk_storage_spec'
+      FileUtils.rm_rf @path
+      @storage = storage.new(:path => @path)
+      @storage.clear!
+      @store = mock("Store")
+      @document = Document.new(@store, 'a' => 1, 'b' => 2)
+      
+      @target_storage = storage.new(:path => "#{@path}_chained")
+      @target_storage.clear!
+      
+      @target_storage1 = storage.new(:path => "#{@path}_chained_1")
+      @target_storage1.clear!
+      
+      @counter = LTS.zero
+    end
+    
+    after(:each) do
+      @target_storage.close!
+      @target_storage1.close!
+    end
+
+    it "should collect update to target store" do
+      @storage.save!(@document,@counter)
+      @storage.add_chained_storage!(@target_storage)
+      @document1 = Document.new(@store, 'x' => 1, 'y' => 2)
+      @storage.save!(@document1,@counter)
+      @target_storage.should_receive(:save!).with(@document1,@counter,{},@storage)
+      @storage.sync_chained_storage!(@target_storage)
+      @storage.sync_chained_storage!(@target_storage)
+    end
+    
+    
+    it "should collect update to multiple target store" do
+      @storage.add_chained_storage!(@target_storage)
+      @storage.save!(@document,@counter)
+      @storage.add_chained_storage!(@target_storage1)
+      @document1 = Document.new(@store, 'x' => 1, 'y' => 2)
+      @storage.save!(@document1,@counter)
+      @target_storage.should_receive(:save!).with(@document,@counter,{},@storage).ordered
+      @target_storage.should_receive(:save!).with(@document1,@counter,{},@storage).ordered
+      @target_storage1.should_receive(:save!).with(@document1,@counter,{},@storage)
+      
+      @storage.sync_chained_storage!(@target_storage)
+      @storage.sync_chained_storage!(@target_storage1)
+    end
+
+    it "should collect update to multiple target store and send them at once" do
+      @storage.add_chained_storage!(@target_storage)
+      @storage.save!(@document,@counter)
+      @storage.add_chained_storage!(@target_storage1)
+      @document1 = Document.new(@store,'x' => 1, 'y' => 2)
+      @storage.save!(@document1,@counter)
+      @target_storage.should_receive(:save!).with(@document,@counter,{},@storage).ordered
+      @target_storage.should_receive(:save!).with(@document1,@counter,{},@storage).ordered
+      @target_storage1.should_receive(:save!).with(@document1,@counter,{},@storage)
+      
+      @storage.sync_chained_storages!
+    end
+
+    it "should collect multiple update to target store" do
+      @storage.save!(@document,@counter)
+      @storage.add_chained_storage!(@target_storage)
+      @document1 = Document.new(@store, 'x' => 1, 'y' => 2)
+      @document2 = Document.new(@store, 'v' => 1, 'z' => 2)
+      @storage.save!(@document1,@counter)
+      @storage.save!(@document2,@counter)
+      @target_storage.should_receive(:save!).with(@document1,@counter,{},@storage).ordered
+      @target_storage.should_receive(:save!).with(@document2,@counter,{},@storage).ordered
+      @storage.sync_chained_storage!(@target_storage)
+    end
+    
+    it "should remove savings sucessfully (current outstanding savings are dropped and new savings are no longer collected)" do
+      @storage.save!(@document,@counter)
+      @storage.add_chained_storage!(@target_storage)
+      @document1 = Document.new(@store,'x' => 1, 'y' => 2)
+      @storage.remove_chained_storage!(@target_storage)
+      @document2 = Document.new(@store,'v' => 1, 'z' => 2)
+      @storage.save!(@document1,@counter)
+      @storage.save!(@document2,@counter)
+      @storage.sync_chained_storage!(@target_storage)
+    end
+    
+    it "should add reverse chaining to target storage when adding chained storage" do
+      @target_storage.should_receive(:add_chained_storage!).with(@storage)
+      @storage.add_chained_storage!(@target_storage)
+    end
+
+    it "should remove reverse chaining from target storage when removing chained storage" do
+      @target_storage.should_receive(:remove_chained_storage!).with(@storage)
+      @storage.add_chained_storage!(@target_storage)
+      @storage.remove_chained_storage!(@target_storage)
+    end
+    
+    it "should not collect savings for target store if these saving where originally from the target store" do
+      @storage.add_chained_storage!(@target_storage)
+      @storage.save!(@document,@counter)
+      @storage.sync_chained_storage!(@target_storage)
+      @storage.should_not_receive(:save!).with(@document,@counter,{},@target_storage)
+      @target_storage.sync_chained_storage!(@storage)
+    end
+    
+    it "should let next storage to sync on sync_chained_storages! as well" do
+      @storage.add_chained_storage!(@target_storage)
+      @storage.save!(@document,@counter)
+      @target_storage.should_receive(:sync_chained_storages!).once
+      @storage.sync_chained_storages!
+    end
+
+  end
+end

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

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

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

@@ -0,0 +1,201 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Store", :shared => true  do
+
+  it "should increment timestamp when storing a document" do
+    @document = Document.new :stuff => '...'
+    lambda do 
+      @store.save!(@document)
+    end.should change(@store,:timestamp)
+  end
+
+  it "should store a document" do
+    @document = Document.new :stuff => '...'
+    @store.save!(@document)
+    (doc = @store.find(@document.uuid)).should == @document
+    doc.should_not be_a_kind_of(VersionedDocument)
+  end
+  
+  it "should store VersionedDocument" do
+    @document = Document.create! :stuff => '...'
+    vd = @document.versions.all.first
+    FileUtils.rm_rf TEMP_STORAGES + '/skiplist_store'
+    another_cfg = StrokeDB::Config.build :base_path => TEMP_STORAGES + '/skiplist_store'
+    another_store = another_cfg.stores[:default]
+    another_store.save!(vd)
+    another_store.find(vd.uuid,vd.version).should == vd
+    another_store.find(vd.uuid).should be_nil
+  end
+
+  it "should be Enumerable" do
+    @store.should be_a_kind_of(Enumerable)
+  end
+
+
+end
+
+describe "New store" do
+
+  before(:each) do
+    @store = setup_default_store
+  end
+  
+  it "should have its own UUID" do
+    @store.uuid.should match(/^#{UUID_RE}$/)
+  end
+
+  it "should have 0 timestamp" do
+    @store.timestamp.should == LTS.zero(@store.uuid)
+  end
+
+  it "should create corresponding StoreInfo document" do
+    @store.document.should be_a_kind_of(StoreInfo)
+    @store.document.uuid.should == @store.uuid
+  end
+
+
+  it "should return nil as head_version for unexistent document (well there is no documents at all)" do
+    @store.head_version(Util.random_uuid).should be_nil
+  end
+
+  it_should_behave_like "Store"
+
+end
+
+
+describe "Non-empty store" do
+
+  before(:each) do
+    @store = setup_default_store
+    setup_index
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:stuff => i)
+    end
+  end
+
+
+  it "should report existing document as such" do
+    @store.include?(@documents.first.uuid).should == true
+  end
+
+  it "should report existing versioned document as such" do
+    @store.include?(@documents.first.uuid,@documents.first.version).should == true
+  end
+
+  it "should report versioned document that does not exist as such" do
+    @store.include?(@documents.first.uuid,'ouch, there is no way such version could be generated').should == false
+  end
+
+  it "should report document that does not exist as such" do
+    @store.include?('ouch, there is no way such UUID could be generated').should == false
+  end
+
+  it "should find a document" do
+    (doc = @store.find(@documents.first.uuid)).should == @documents.first
+    doc.should_not be_a_kind_of(VersionedDocument)
+  end
+
+  it "should find a versioned document" do
+    (doc = @store.find(@documents.first.uuid,@documents.first.version)).should == @documents.first
+    doc.should be_a_kind_of(VersionedDocument)
+  end
+
+  it "should not find a versioned document with version that does not exist" do
+    @store.find(@documents.first.uuid,'absolutely absurd version').should be_nil
+  end
+
+
+  it "should iterate over all stored documents" do
+    iterated_documents = []
+    @store.each do |doc|
+      iterated_documents << doc
+    end
+    iterated_documents.sort_by {|doc| doc.uuid}.should == @documents.sort_by {|doc| doc.uuid}
+  end
+
+  it "should iterate over all stored documents and their versions if told so" do
+    iterated_documents = []
+    @store.each(:include_versions => true) do |doc|
+      iterated_documents << doc
+    end
+    documents_with_versions = @documents.clone
+    @documents.each do |doc|
+      doc.versions.all.each do |vd|
+        documents_with_versions << vd
+      end
+    end
+    iterated_documents.sort_by {|doc| doc.uuid}.should == documents_with_versions.sort_by {|doc| doc.uuid}
+  end
+
+  it "should iterate over all newly stored documents if told so" do
+    timestamp = @store.timestamp.counter
+    @new_documents = []
+    10.times do |i|
+      @new_documents << Document.create!(:stuff => i)
+    end
+
+    iterated_documents = []
+    @store.each(:after_timestamp => timestamp) do |doc|
+      iterated_documents << doc
+    end
+    iterated_documents.sort_by {|doc| doc.uuid}.should == @new_documents.sort_by {|doc| doc.uuid}
+  end
+
+  it "should iterate over all newly stored versions if told so" do
+    timestamp = @store.timestamp.counter
+    @new_documents = []
+    @documents.each_with_index do |document,i|
+      document.stuff = i+100
+      @new_documents << document.save!
+    end
+
+    iterated_documents = []
+    @store.each(:after_timestamp => timestamp, :include_versions => true) do |doc|
+      iterated_documents << doc
+    end
+    iterated_documents.sort_by {|doc| doc.uuid}.should == (@documents + @new_documents).sort_by {|doc| doc.uuid}
+  end
+
+
+  it_should_behave_like "Store"
+
+
+end
+
+# 
+# describe "[Regression] First chunk cut" do
+# 
+# 
+#   before(:all) do
+#     @store = setup_default_store
+#     @doc1 = Document.new(@store,:stuff => 123)
+#     @doc2 = Document.new(@store,:stuff => 123)
+#     @doc3 = Document.new(@store,:stuff => 123)
+#   end
+# 
+#   it "should store a document with big uuid in a first chunk" do
+#     $DEBUG_CHEATERS_LEVEL = 2
+#     @store.save!(@doc3)
+#     @store.find(@doc3.uuid).uuid.should == @doc3.uuid
+#     #  end
+#     #  it "should store a document with lower uuid in a first chunk" do
+#     $DEBUG_CHEATERS_LEVEL = 2
+#     @store.save!(@doc1)
+#     @store.find(@doc1.uuid).uuid.should == @doc1.uuid
+#     @store.find(@doc3.uuid).uuid.should == @doc3.uuid
+#     #  end
+#     #  it "should cut a chunk with a document with medium uuid" do
+#     $DEBUG_CHEATERS_LEVEL = 5
+#     @store.save!(@doc2)
+#     @store.find(@doc1.uuid).uuid.should == @doc1.uuid
+#     @store.find(@doc3.uuid).uuid.should == @doc3.uuid
+#     @store.find(@doc2.uuid).uuid.should == @doc2.uuid
+#   end
+# 
+#   after(:each) do
+#     $DEBUG_CHEATERS_LEVEL = nil
+#   end
+# end
+
+