strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/util/lazy_mapping_hash_spec.rb

@@ -0,0 +1,92 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "LazyMappingHash instance" do
+  
+  before(:each) do
+    @lash = LazyMappingHash.new
+  end
+  
+  it "should have class Hash" do
+    @lash.class.should == Hash
+  end
+  
+  it "should be inherited from Hash" do
+    @lash.class.ancestors.first.should == Hash
+  end
+  
+  it "should match case expressions" do
+    @lash.should be_a_kind_of(Hash)
+  end
+end
+
+describe "LazyMappingHash instance with block specified" do
+  before(:each) do
+    @original = Hash[1,2,3,4,5,6]
+    @decoder = proc {|k| k.is_a?(Hash) && k[:struct] || k }
+    @encoder = proc {|k| {:struct => k}  }
+    
+    @lash = LazyMappingHash.new(@original).map_with(&@encoder).unmap_with(&@decoder)
+  end
+  
+  it "should call mapping proc on #keys" do
+    @lash.keys.should == @original.keys.map {|k| @encoder.call(k)}
+  end
+
+  it "should call mapping proc on #values" do
+    @lash.values.should == @original.values.map {|k| @encoder.call(k)}
+  end
+  
+  it "should call unmapping proc on #[key]=" do
+    @lash[1] = { :struct => :x }
+    Hash[@lash][1].should == :x
+    @lash[{:struct => :x}] = 1
+    Hash[@lash][:x].should == 1
+  end
+  
+  it "should call mapping proc on #[key]" do
+    @lash[1].should == @encoder.call(@original[1])
+    @lash[2].should == @encoder.call(@original[2])
+  end
+  
+  it "should call mapping proc on #[mapped_key]" do
+    @lash[@encoder.call(1)].should == @encoder.call(@original[1])
+    @lash[@encoder.call(2)].should == @encoder.call(@original[2])
+  end
+  
+  it "should yield mapped key/value in #each block" do
+    orig_kv = []
+    lash_kv = []
+    @original.each do |k, v|
+      orig_kv << [@encoder.call(k), @encoder.call(v)]
+    end
+    @lash.each do |k, v|
+      lash_kv << [k,v]
+    end
+    orig_kv.should == lash_kv
+  end
+  
+  it "should yield mapped key/value in #map block" do
+    orig_kv = @original.map do |k, v|
+      [@encoder.call(k), @encoder.call(v)]
+    end
+    lash_kv = @lash.map do |k, v|
+      [k, v]
+    end
+    orig_kv.should == lash_kv
+  end
+  
+  it "should yield mapped key/value in #zip block (lash.zip(original))" do
+    orig_kv = []
+    lash_kv = []
+    @original.zip(@original) do |kv1, kv2|
+      orig_kv << [kv1.map{|e| @encoder.call(e)}, kv2]
+    end
+    @lash.zip(@original) do |kv1, kv2|
+      lash_kv << [kv1, kv2]
+    end
+    orig_kv.should == lash_kv
+  end
+    
+  # TODO: zip support
+  
+end

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

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

data/spec/lib/strokedb/util/uuid_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "String UUID" do
+  it "should have specific format" do
+    1000.times do 
+      uuid = Util::random_uuid
+      uuid.should =~ /^#{UUID_RE}$/
+    end
+  end
+  it "should be converted to raw string" do
+    "00000000-0000-0000-0000-000000000010".to_raw_uuid.should == "\x00"*15 + "\x10"
+    "ffffffff-ffff-ffff-ffff-ffffffffffff".to_raw_uuid.should == "\xff"*16
+    "00000000-0000-0000-ffff-ffffffffffff".to_raw_uuid.should == "\x00"*8 + "\xff"*8
+  end
+end
+
+describe "Raw UUID" do
+  it "should have specific format" do
+    1000.times do 
+      uuid = Util::random_uuid_raw
+      uuid.should be_an_instance_of(String)
+      uuid.size.should == 16 
+    end
+  end
+  it "should be converted to formatted string" do
+    ("\x00"*15 + "\x10").to_formatted_uuid.should == "00000000-0000-0000-0000-000000000010"
+    ("\xff"*16).to_formatted_uuid.should          == "ffffffff-ffff-ffff-ffff-ffffffffffff"
+    ("\x00"*8 + "\xff"*8).to_formatted_uuid.should      == "00000000-0000-0000-ffff-ffffffffffff"
+  end
+end
+
+describe "UUID String conversion" do
+  it "should convert raw to formatted and back" do
+    1000.times do
+      raw = Util::random_uuid_raw
+      raw.to_formatted_uuid.to_raw_uuid.should == raw
+    end
+  end
+  it "should convert formatted to raw and back" do
+    1000.times do
+      fmt = Util::random_uuid
+      fmt.to_raw_uuid.to_formatted_uuid.should == fmt
+    end
+  end
+end
+

data/spec/lib/strokedb/view_spec.rb

@@ -0,0 +1,228 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "View without map_with and reduce_with blocks" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "without block")
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents plus Meta and View" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit.to_a.sort_by {|doc| doc.uuid}.should == (@documents + [Meta.document,View.document,ViewCut.document]).sort_by {|doc| doc.uuid}
+  end
+
+end
+
+describe "View with map_with (without extra arguments)" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "with map_with (without extra arguments)").map_with {|doc| doc.slotnames.include?('i') ? doc : nil}
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents plus three nils" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit.to_a.sort_by {|doc| doc.nil? ? "0" : doc.uuid}.should == (@documents + [nil,nil,nil]).sort_by {|doc| doc.nil? ? "0" :  doc.uuid}
+  end
+
+end
+
+describe "View with map_with (with extra arguments)" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "with map_with (with extra arguments)").map_with {|doc,slotname| doc.slotnames.include?(slotname.to_s) ? doc : nil}
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents plus three nils" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit(:i).to_a.sort_by {|doc| doc.nil? ? "0" : doc.uuid}.should == (@documents + [nil,nil,nil]).sort_by {|doc| doc.nil? ? "0" :  doc.uuid}
+  end
+
+end
+
+describe "View with map_with and reduce_with" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "with map_with and reduce_with").map_with {|doc| doc.slotnames.include?('i') ? doc : nil}.reduce_with{|doc| !doc.nil? }
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit.to_a.sort_by {|doc| doc.uuid}.should == @documents.sort_by {|doc| doc.uuid}
+  end
+
+end
+
+describe "View with reduce_with" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "with reduce_with").reduce_with{|doc| doc.slotnames.include?('i') }
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit.to_a.sort_by {|doc| doc.uuid}.should == @documents.sort_by {|doc| doc.uuid}
+  end
+
+end
+
+describe "View with reduce_with (with extra arguments)" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "with reduce_with (with extra arguments)").reduce_with {|doc,slotname| doc.slotnames.include?(slotname.to_s) }
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should return all documents plus two nils" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit(:i).to_a.sort_by {|doc| doc.uuid}.should == @documents.sort_by {|doc| doc.uuid}
+  end
+
+end
+
+describe "View" do
+
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new(:name => "incremental view").reduce_with{|doc| doc.slotnames.include?('i') }
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+
+  it "should make documents VersionedDocuments" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    @view.emit.to_a.each {|d| d.should be_a_kind_of(VersionedDocument)}
+  end
+  
+  it "should be able to return new documents incrementally" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    cut = @view.emit
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i+100)
+    end
+    a = cut.emit.to_a
+    a.sort_by {|doc| doc.uuid }.should == @documents.sort_by {|doc| doc.uuid }
+    a.each {|d| d.should be_a_kind_of(VersionedDocument)} # make sure next emit produces VersionedDocuments as well
+  end
+  
+  it "should be able to return new document heads incrementally" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    cut = @view.emit
+    new_docs = @documents.map {|doc| doc.new_slot = "new"; doc.save!}
+    a = cut.emit.to_a
+    a.sort_by {|doc| doc.uuid }.should == new_docs.sort_by {|doc| doc.uuid }
+  end
+
+  it "should be able to return new document versions incrementally if told so" do
+    @documents = []
+    10.times do |i|
+      @documents << Document.create!(:i => i)
+    end
+    cut = @view.emit
+    @view.include_versions = true
+    @view.save!
+    new_docs = @documents.map {|doc| doc.new_slot = "new"; doc.save!}
+    docs = @documents.map {|doc| doc.reload }
+    a = cut.emit.to_a
+    a.sort_by {|doc| doc.uuid }.should == (new_docs+docs).sort_by {|doc| doc.uuid }
+  end
+
+end
+
+describe "Newly created View" do
+  
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+  end
+  
+  it "should reference first cut as last cut when it is saved" do
+    cut = @view.emit
+    cut.save!
+    @view.last_cut.should == cut
+  end
+  
+  it "save view on first cut save" do
+    cut = @view.emit
+    cut.save!
+    @view.should_not be_new
+  end
+  
+end
+
+describe "View with cut(s) available" do
+  
+  before(:each) do
+    setup_default_store
+    setup_index
+    @view = View.new
+    ViewCut.document # this is to ensure that ViewCut document is created prior to emitting more data in cuts
+    @cut = @view.emit
+    @cut.save!
+  end
+  
+  it "should refer to newly emitted cut as last cut (when it is saved)" do
+    new_cut = @cut.emit
+    @view.reload.last_cut.should == @cut
+    new_cut.save!
+    @view.reload.last_cut.should == new_cut
+  end
+
+  it "should not refer to newly emitted cut as last cut (when it is saved) if this cut isn't really last" do
+    new_cut = @cut.emit
+    new_cut.save!
+    @view.reload.last_cut.should == new_cut
+    another_cut = @cut.emit
+    another_cut.save!
+    @view.reload.last_cut.should == new_cut.reload # we are reloading new_cut to let it have DocRefs instead of loaded documents
+                                                   # just for the sake of this comparison
+                                                   # However TODO: investigate this
+  end
+  
+end

data/spec/lib/strokedb/volumes/archive_volume_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ArchiveVolume, "initialization" do
+
+  before(:all) do
+    FileUtils.rm_rf TEMP_STORAGES + '/archive_volume_spec'
+  end
+  
+  before(:each) do
+    @path = TEMP_STORAGES + '/archive_volume_spec'
+    @size     = 64*1024
+    @options = {:size => @size, :path => @path}
+  end
+  
+  it "should go well with raw uuid" do
+    raw_uuid = Util.random_uuid_raw
+    ArchiveVolume.new(@options.merge(:uuid => raw_uuid)).uuid.should == raw_uuid.to_formatted_uuid
+  end
+
+  it "should go well with formatted uuid" do
+    uuid = Util.random_uuid
+    ArchiveVolume.new(@options.merge(:uuid => uuid)).uuid.should == uuid
+  end
+  
+  it "should generate new UUID if none given" do
+    ArchiveVolume.new(@options).uuid.should match(/#{UUID_RE}/)
+  end
+  
+  
+end
+
+describe ArchiveVolume do
+  
+  before(:all) do
+    FileUtils.rm_rf TEMP_STORAGES + '/archive_volume_spec'
+  end
+  
+  before(:each) do
+    @path = TEMP_STORAGES + '/archive_volume_spec'
+    @raw_uuid = Util.random_uuid_raw
+    @size     = 64*1024
+    @options = {:uuid => @raw_uuid, :size => @size, :path => @path}
+  end
+
+  it "should be created with given size" do 
+    dv = ArchiveVolume.new(@options)
+    fname = dv.file_path
+    File.should be_exist(fname)
+    File.size(fname).should == @size
+    File.open(fname){|f| f.read }[4..-1].should == "\x00"*(@size-4)
+    dv.delete!
+    File.should_not be_exist(fname)
+  end
+  
+  it "should write some data and return its position" do
+    dv = ArchiveVolume.new(@options)
+    tail = dv.tail
+    tail.should == 4
+    prefix = 4
+    
+    p1 = dv.insert("7 bytes")
+    p1.should == 0 + tail
+    p2 = dv.insert("13 more bytes")
+    p2.should == 7 + prefix + tail
+    p3 = dv.insert("1")
+    p3.should == 20 + prefix*2 + tail
+    dv.close!
+  end
+  
+  it "should read & write data" do
+    dv = ArchiveVolume.new(@options)
+    p1 = dv.insert("7 bytes")
+    p2 = dv.insert("13 more bytes")
+    p3 = dv.insert("1")
+    
+    dv.read(p2).should == "13 more bytes"
+    dv.read(p1).should == "7 bytes"
+    dv.read(p3).should == "1"
+    
+    p4 = dv.insert("")
+    
+    dv.read(p2).should == "13 more bytes"
+    dv.read(p1).should == "7 bytes"
+    dv.read(p3).should == "1"
+    dv.read(p4).should == ""
+    
+    dv.close!
+  end
+  
+  it "should raise exception if file is closed" do
+    dv = ArchiveVolume.new(@options)
+    dv.close!
+    
+    lambda { dv.read(4)       }.should raise_error(ArchiveVolume::VolumeClosedException)
+    lambda { dv.insert("data") }.should raise_error(ArchiveVolume::VolumeClosedException)
+  end
+  
+  it "should raise exception if capacity is exceeded" do
+    dv = ArchiveVolume.new(@options)
+    # Since ArchiveVolume maintains some system information like header and record size
+    # record size of file size will exceed volume's capacity
+    lambda { dv.insert(" "*@size) }.should raise_error(ArchiveVolume::VolumeCapacityExceeded)
+  end
+  
+end