strokedb 0.0.2.1 → 0.0.2.2

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

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe BlockVolume, "initialization" do
+
+  before(:all) do
+    FileUtils.rm_rf TEMP_STORAGES + '/block_volume_spec'
+  end
+  
+  before(:each) do
+    @path = TEMP_STORAGES + '/block_volume_spec'
+    @size     = 2
+    @count    = 2
+    @options = {:block_size => @size, 
+                :blocks_count => @count, 
+                :path => @path}
+  end
+  
+  it "should go well with raw uuid" do
+    raw_uuid = Util.random_uuid_raw
+    BlockVolume.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
+    BlockVolume.new(@options.merge(:uuid => uuid)).uuid.should == uuid
+  end
+  
+  it "should generate new UUID if none given" do
+    BlockVolume.new(@options).uuid.should match(/#{UUID_RE}/)
+  end
+  
+  
+end
+
+describe BlockVolume do
+  
+  before(:all) do
+    FileUtils.rm_rf TEMP_STORAGES + '/block_volume_spec'
+  end
+  
+  before(:each) do
+    @path = TEMP_STORAGES + '/block_volume_spec'
+    @raw_uuid = Util.random_uuid_raw
+    @size     = 2
+    @count    = 2
+    @options = {:uuid => @raw_uuid, 
+                :block_size => @size, 
+                :blocks_count => @count, 
+                :path => @path}
+  end
+  
+  it "should be created with given size" do 
+    dv = BlockVolume.new(@options)
+    fname = dv.file_path
+    File.should be_exist(fname)
+    File.size(fname).should == 8 + 2*@size
+    File.open(fname){|f| f.read }[8..-1].should == "\x00"*(@size*2)
+    dv.delete!
+    File.should_not be_exist(fname)
+  end
+  
+  it "should write some data and read it" do
+    dv = BlockVolume.new(@options)
+    dv.insert(0, "x")
+    dv.read(0).should == "x\x00"
+    dv.insert(1, "y")
+    dv.read(1).should == "y\x00"
+    dv.close!
+  end
+  
+  it "should overwrite some data and read it" do
+    dv = BlockVolume.new(@options)
+    dv.insert(0, "x")
+    dv.read(0).should == "x\x00"
+    dv.insert(0, "y")
+    dv.read(0).should == "y\x00"
+    dv.close!
+  end
+  
+  it "should extend volume" do
+    dv = BlockVolume.new(@options)
+    dv.insert(0, "x")
+    dv.read(0).should == "x\x00"
+    dv.insert(1, "y")
+    dv.read(1).should == "y\x00"
+    dv.insert(2, "z")
+    dv.read(2).should == "z\x00"
+    dv.read(3).should == "\x00\x00"
+    dv.close!
+  end
+    
+  it "should raise exception if file is closed" do
+    dv = BlockVolume.new(@options)
+    dv.close!
+    
+    lambda { dv.read(0)       }.should raise_error(BlockVolume::VolumeClosedException)
+    lambda { dv.insert(0, "d") }.should raise_error(BlockVolume::VolumeClosedException)
+  end
+  
+end

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

@@ -0,0 +1,14 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "DistributedPointer" do
+  it "should be packed correctly" do
+    dp = DistributedPointer.new("\xff"*16, 1)
+    dp.pack.should == "\xff"*16 + "\x01\x00\x00\x00"
+  end
+  
+  it "should be unpacked correctly" do
+    dp = DistributedPointer.unpack("\xff"*16 + "\x05\x00\x00\x00")
+    dp.volume_uuid.should == "\xff"*16
+    dp.offset.should == 5
+  end
+end

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

@@ -0,0 +1,177 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+# SimpleSkiplist.with_optimizations(OPTIMIZATIONS) do |lang|
+lang = "Ruby" # FIXME: it is a (temporary?) workaround to let this spec work fine together with simple_skiplist_spec
+
+describe "Empty FixedLengthSkiplistVolume [#{lang}]" do
+
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+  end
+
+  it "should be empty" do
+    @list.should be_empty
+  end
+
+  it "should find nil in a empty skiplist" do
+    @list.find("x"*10).should == nil
+  end
+
+end
+
+
+describe "Inserting in a skiplist [#{lang}]" do
+
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+  end
+
+  it "should insert non-empty key" do
+    @list.insert("x"*10, "4"*10, 1).should == @list
+    @list.find("x"*10).should == "4"*10
+    @list.find("y"*10).should be_nil
+  end
+
+  it "should correctly insert keys in an ascending level order" do
+    1.upto(@maxlevel) do |i|
+      k = "x#{i}".ljust(10,'0')
+      @list.insert(k, k, i).should == @list
+      @list.find(k).should == k
+      @list.find("-"*10).should == nil
+    end
+    # repeat
+    1.upto(@maxlevel) do |i|
+      k = "x#{i}".ljust(10,'0')
+      @list.find(k).should == k
+    end
+  end
+
+  it "should correctly insert keys in a descending level order" do
+    @maxlevel.downto(1) do |i|
+      k = "x#{@maxlevel-i}".ljust(10,'0')
+      @list.insert(k, k, i).should == @list
+      @list.find(k).should == k
+      @list.find("-"*10).should == nil
+    end
+    # repeat
+    @maxlevel.downto(1) do |i|
+      k = "x#{@maxlevel-i}".ljust(10,'0')
+      @list.find(k).should == k
+    end
+  end  
+end
+
+
+describe "Big skiplist [#{lang}]" do
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 20, :value_length => 20)
+    1000.times do 
+      v = k = rand(2**64).to_s.rjust(20,'0')
+      @list.insert(k, v)
+    end
+  end
+
+
+  it "should support to_a with sorted key-value pairs" do
+    ary = @list.to_a
+    ary.should == ary.sort{|a,b| a[0] <=> b[0] }
+    ary.size.should == 1000
+  end
+end
+
+
+describe "FixedLengthSkiplistVolume#first_key [#{lang}]" do
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+  end
+  it "should return nil for empty skiplist" do
+    @list.first_key.should == nil
+  end
+  it "should return key for non-empty skiplist" do
+    @list.insert("b"*10, "1"*10)
+    @list.first_key.should == "b"*10
+    @list.insert("c"*10, "2"*10)
+    @list.first_key.should == "b"*10
+  end
+end
+
+
+describe "FixedLengthSkiplistVolume#find_nearest [#{lang}]" do
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+  end
+  it "should find zero value in empty skiplist" do
+    @list.find_nearest("a").should == "\x00"*10
+    @list.find_nearest("").should == "\x00"*10
+    @list.find_nearest(nil).should == "\x00"*10
+  end
+  it "should find exact value if it is present" do
+    @list.insert("b"*10, "B"*10)
+    @list.insert("f"*10, "F"*10)
+    @list.find_nearest("b"*10).should == "B"*10
+    @list.find_nearest("f"*10).should == "F"*10
+  end
+  it "should find nearest value or nil" do
+    @list.insert("b"*10, "B"*10)
+    @list.insert("f"*10, "F"*10)
+    @list.find_nearest("a"*10).should == "\x00"*10
+    @list.find_nearest("c"*10).should == "B"*10
+    @list.find_nearest("g"*10).should == "F"*10
+  end
+  # it "should always find empty-string key if nothing found" do
+  #   @list.insert("",  "Empty")
+  #   @list.insert("b", "B")
+  #   @list.insert("f", "F")
+  #   @list.find_nearest("a").should == "Empty"
+  #   @list.find_nearest("c").should == "B"
+  #   @list.find_nearest("g").should == "F"
+  # end
+end
+describe "Saved FixedLengthSkiplistVolume" do
+  before(:each) do
+    @maxlevel    = 8
+    @probability = 0.5
+    @path = TEMP_STORAGES + '/fixed_length_sl_volume'
+    FileUtils.rm_rf @path
+    @list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+  end
+
+  it "with actual data inside should be loaded properly" do
+    @list.insert("A"*10,"B"*10)
+    @list.close!
+    @new_list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+    @new_list.find("A"*10).should == "B"*10
+  end
+  it "with no actual data inside should be loaded properly" do
+    @list.close!
+    @new_list = FixedLengthSkiplistVolume.new(:path => @path, :maxlevel => @maxlevel, :probability => @probability, :key_length => 10, :value_length => 10)
+    @new_list.find("A"*10).should == nil
+  end
+
+end
+# end
+
+def raw_list(list)
+  list.marshal_dump[:raw_list]
+end
+

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

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+[MapVolume].each do |klass|
+describe "#{klass}", :shared => true do
+
+  it "should have record size" do
+    @map_volume.record_size.should == 256
+  end
+  
+  it "should insert record of proper size" do
+    @map_volume.insert!("A"*256)
+  end
+
+  it "should insert record of proper size and return non-negative position" do
+    @map_volume.insert!("A"*256).should >= 0
+  end
+  
+  it "should be able to read inserted record" do
+    @map_volume.read(@map_volume.insert!("A"*256)).should == "A"*256
+  end
+
+  it "should return different positions for each insertion" do
+    positions = (1..50).map { @map_volume.insert!("A"*256) }
+    positions.uniq.should == positions
+  end
+  
+  it "should not insert record of improper size" do
+    lambda { @map_volume.insert!(" "*255) }.should raise_error(InvalidRecordSizeError)
+    lambda { @map_volume.insert!(" "*257) }.should raise_error(InvalidRecordSizeError)
+  end
+  
+
+  it "should insert new record into previously deleted position" do
+     @map_volume.insert!(" "*256)
+     position = @map_volume.insert!(" "*256)
+     @map_volume.delete!(position)
+     @map_volume.insert!(" "*256).should == position
+  end
+
+  it "should raise an exception if trying to read previously deleted record" do
+     @map_volume.insert!(" "*256)
+     position = @map_volume.insert!(" "*256)
+     @map_volume.delete!(position)
+     lambda { @map_volume.read(position) }.should raise_error(InvalidRecordPositionError)
+  end
+  
+  
+  it "should be able to write record at specified position" do
+    position = @map_volume.insert!("A"*256)
+    @map_volume.write!(position,"B"*256).should == position
+    @map_volume.read(position).should == "B"*256
+  end  
+
+  it "should be able to write record at specified position if there is no record yet" do
+    @map_volume.write!(0,"O"*256).should == 0
+    @map_volume.available?(0).should == false
+  end  
+  
+  it "should be able to insert records of size that is greater than record size elastically" do
+    position = @map_volume.elastic_insert!("E"*300)
+    @map_volume.elastic_read(position).should == "E"*300
+    (300%8).times {|n| @map_volume.available?(position+n).should == false }
+  end
+
+  it "should be able to insert records of size that is less than record size - 4 when using elastic way" do
+    position = @map_volume.elastic_insert!("E"*252)
+    @map_volume.elastic_read(position).should == "E"*252
+    @map_volume.available?(position).should == false
+  end
+
+  it "should be able to insert records of size that is greater than record size elastically when bitmap can't fit it" do
+    (@map_volume.map_size).times { @map_volume.insert!('N'*256)}
+    position = @map_volume.elastic_insert!("E"*1024)
+    @map_volume.elastic_read(position).should == "E"*1024
+  end
+
+  
+  
+end
+
+describe "New #{klass}" do
+  
+  before(:each) do
+    @path = TEMP_STORAGES + "/map.volume.#{klass}"
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+    @map_volume = klass.new(:path => @path, :record_size => 256)
+  end
+  
+  after(:each) do
+    @map_volume.close!
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+  end
+  
+  it "should be empty" do
+    @map_volume.should be_empty
+  end
+  
+  it "should have bitmap allocated for 65536 records" do
+    (@map_volume.map_size * 8).should == 65536
+  end
+  
+  it_should_behave_like "#{klass}"
+  
+end
+
+describe "New #{klass} with bitmap extension pace of 16384" do
+  
+  before(:each) do
+    @path = TEMP_STORAGES + "/map.volume.#{klass}"
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+    @map_volume = klass.new(:path => @path, :record_size => 256, :bitmap_extension_pace => 16384)
+  end
+  
+  after(:each) do
+    @map_volume.close!
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+  end
+  
+  it "should have bitmap allocated for 131072 records" do
+    (@map_volume.map_size * 8).should == 131072
+  end
+  
+  it_should_behave_like "#{klass}"
+  
+end
+
+
+describe "Existing MapVolume" do
+  
+  before(:each) do
+    @path = TEMP_STORAGES + "/map.volume.#{klass.name.to_s.demodulize}"
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+    @map_volume = klass.new(:path => @path, :record_size => 256, :capacity => 100)
+    position = @map_volume.insert!(' '*256)
+    @map_volume.close!
+    @map_volume = klass.new(:path => @path)
+  end
+  
+  after(:each) do
+    @map_volume.close!
+    FileUtils.rm_rf(@path) if File.exists?(@path)
+  end
+
+  it "should not be empty" do
+    @map_volume.should_not be_empty
+  end
+  
+  it_should_behave_like "#{klass}"
+  
+end
+
+describe "Opening invalid file with #{klass} (i.e. file with invalid signature)" do
+
+  before(:each) do
+    @path = TEMP_STORAGES + "/map.volume.#{klass.name.to_s.demodulize}"
+    FileUtils.rm_rf(@path + ".invalid") if File.exists?(@path + ".invalid")
+    FileUtils.mkdir_p(@path + ".invalid")
+    File.open(@path + ".invalid/bitmap","w+") do |f|
+      f.write "Invalid file"
+    end
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(@path + ".invalid") if File.exists?(@path + ".invalid")
+  end
+  
+  it "should fail with InvalidMapVolumeError exception" do
+    lambda { klass.new(:path => @path + ".invalid") }.should raise_error(InvalidMapVolumeError)
+  end
+  
+end
+end