strokedb 0.0.2.1 → 0.0.2.2

data/spec/lib/strokedb/core_ext/blank_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+
+describe "fasle" do
+  it "should be blank" do
+    false.should be_blank
+  end
+end
+
+describe "true" do
+  it "should not be blank" do
+    true.should_not be_blank
+  end
+end
+
+describe "Numeric" do
+  it "should not be blank" do
+    Numeric.should_not be_blank
+  end
+end

data/spec/lib/strokedb/core_ext/extract_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Kernel#extract" do
+  
+  it "should correctly extract various arguments" do
+    extract(Regexp, String, Hash, [          ]).should == [nil, nil, nil]
+    
+    extract(Regexp, String, Hash, [/a/       ]).should == [/a/, nil, nil]
+    extract(Regexp, String, Hash, [    "a"   ]).should == [nil, "a", nil]
+    extract(Regexp, String, Hash, [    {1=>2}]).should == [nil, nil, {1=>2}]
+    
+    extract(Regexp, String, Hash, [//, ""    ]).should == [//,  "",  nil]
+    extract(Regexp, String, Hash, [//,     {}]).should == [//,  nil, {} ]
+    extract(Regexp, String, Hash, [    "", {}]).should == [nil,  "",  {}]
+    
+    extract(Regexp, String, Hash, [//, "", {}]).should == [//,  "",  {} ]
+  end
+  
+  it "should raise ArgumentError when wrong arguments are passed" do
+    
+    bad_case(Regexp, String, Hash, [123])
+    bad_case(Regexp, String, Hash, ["", //])
+    bad_case(Regexp, String, Hash, [{}, ""])
+    bad_case(Regexp, String, Hash, [true])
+    bad_case(Regexp, String, Hash, [false])
+    bad_case(Regexp, String, Hash, [//,false])
+    bad_case(Regexp, String, Hash, [nil])
+    bad_case(Regexp, String, Hash, ["", nil])
+    bad_case(Regexp, String, Hash, [nil, nil])
+    bad_case(Regexp, String, Hash, [{}, {}])
+    bad_case(Regexp, String, Hash, [//, //])
+    bad_case(Regexp, String, Hash, [ [] ])
+    bad_case(Regexp, String, Hash, [Object.new])
+    bad_case(Regexp, String, Hash, [Object.new, Object.new])
+    
+  end
+  
+  def bad_case(*args)
+    lambda { extract(*args) }.should raise_error(ArgumentError)
+  end
+  
+end

data/spec/lib/strokedb/core_ext/float_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Infinity do
+
+  it "should correctly compare with integers and floats" do
+    Infinity.should > 1
+    Infinity.should > 1.0
+  end
+    
+  it "should correctly work with ranges" do
+    (-Infinity..1).should include(-100)
+    (-Infinity..Infinity).should include(Float::MAX)
+    (0..Infinity).should include(Float::MAX)
+  end
+  
+  it "should return Infinity in arithmetics" do
+    (Infinity + Infinity).should == Infinity
+    (Infinity * Infinity).should == Infinity
+    (Infinity ** Infinity).should == Infinity
+    (Infinity / 0).should == Infinity
+    (Infinity / 0.0).should == Infinity
+  end
+  
+  it "should return NaN in arithmetics" do
+    (Infinity - Infinity).should be_nan
+    (Infinity / Infinity).should be_nan
+    (Infinity * 0).should be_nan
+    (Infinity * 0.0).should be_nan
+  end
+  
+end
+
+describe NaN do
+  
+  it "should correctly compare with numerics" do
+    (NaN < 1).should be_false
+    (NaN > 1).should be_false
+    (NaN == 1).should be_false
+  end
+  
+  it "should not compare with itself" do
+    NaN.should_not == NaN
+    NaN.should be_nan
+    NaN.object_id.should == NaN.object_id
+    (NaN + 1).object_id.should_not == NaN.object_id
+  end
+
+  it "should produce NaN in all the operations except NaN**0 == 1" do
+    (NaN + 1).should be_nan
+    (NaN + Infinity).should be_nan
+    (NaN - 1).should be_nan
+    (NaN * 0).should be_nan
+    (NaN * Infinity).should be_nan
+    (NaN ** 0).should == 1  # <-- WTF?  (Ruby 1.8.6 rel. 2007-03-13)
+    (NaN ** 1).should be_nan
+    (NaN ** Infinity).should be_nan
+    (NaN / 0).should be_nan
+    (NaN / 1).should be_nan
+    (NaN / Infinity).should be_nan
+  end
+  
+end

data/spec/lib/strokedb/core_ext/infinity_spec.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Object#infinity?" do
+  it "should return false for the finite values" do
+    Object.should_not be_infinite
+    Object.new.should_not be_infinite
+    String.new.should_not be_infinite
+    Time.now.should_not be_infinite
+    :sym.should_not be_infinite
+    nil.should_not be_infinite
+    false.should_not be_infinite
+    true.should_not be_infinite
+    Float::MAX.should_not be_infinite
+    2.71828.should_not be_infinite
+    42.should_not be_infinite
+    (1..Infinity).should_not be_infinite # yep, this too.
+  end
+  it "should return true for infinite 'values'" do
+    Infinity.should be_infinite
+    (-Infinity).should be_infinite
+    (InfiniteString).should be_infinite
+    (InfiniteTime).should be_infinite
+  end 
+end
+
+describe InfiniteString do
+  it "should be used in Range" do
+    (InfiniteString.."a").should be_a_kind_of(Range)
+    ("a"..InfiniteString).should be_a_kind_of(Range)
+    (InfiniteString..InfiniteString).should be_a_kind_of(Range)
+  end
+end
+
+describe InfiniteTime do
+  it "should be used in Range" do
+    (InfiniteTime..Time.now).should be_a_kind_of(Range)
+    (Time.now..InfiniteTime).should be_a_kind_of(Range)
+    (InfiniteTime..InfiniteTime).should be_a_kind_of(Range)
+  end
+end

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

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

data/spec/lib/strokedb/core_ext/string_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "String#/" do
+  it "should concatenate strings with /" do
+    "lib"/"core_ext".should == "lib/core_ext"
+    "lib/core_ext"/"foo".should == "lib/core_ext/foo"
+  end
+end
+
+describe "String#modulize" do
+
+  it "if there is no module, leave nothing" do
+    "A".modulize.should == ""
+    "::A".modulize.should == ""
+  end
+  
+  it "should leave single module" do
+    "A::B".modulize.should == "A"
+  end
+
+  it "should leave multiple modules" do
+    "A::B::C".modulize.should == "A::B"
+  end
+
+end

data/spec/lib/strokedb/core_ext/symbol_spec.rb

@@ -0,0 +1,8 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Symbol#/" do
+  it "should concatenate symbols with / as a string" do
+    :lib/:core_ext.should == "lib/core_ext"
+    :lib/:core_ext/:foo.should == "lib/core_ext/foo"
+  end
+end

data/spec/lib/strokedb/data_structures/chunked_skiplist_spec.rb

@@ -0,0 +1,144 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Empty chunked skiplist" do
+  before(:each) do
+    @cut_level = 4
+    @list = Skiplist.new({}, nil, @cut_level)
+  end
+  
+  it "should make first node level first-level only" do
+    @list.head.level.should == 1
+    @list.insert("k","v", @cut_level + 1)
+    @list.head.level.should == 1
+    @list.head.forward[0].level.should == 1
+  end
+  
+end
+
+
+describe "Chunked skiplist (variants)" do
+  
+  before(:each) do
+    @cut_level = 16
+  end
+
+  it "should be valid with ascending level order" do
+    @list = Skiplist.new({}, nil, @cut_level)
+    (1..10).each do |i|
+      @list.insert("K#{i*10}", "V", i)
+    end
+    @list.should have(10).items
+  end
+  
+  it "should be valid with descending level order" do
+    @list = Skiplist.new({}, nil, @cut_level)
+    (1..10).each do |i|
+      @list.insert("K#{i*10}", "V", 11 - i)
+    end
+    @list.should have(10).items
+  end
+  
+  it "should be valid with fixed level order" do
+    @list = Skiplist.new({}, nil, @cut_level)
+    (1..10).each do |i|
+      @list.insert("K#{i*10}", "V", 15)
+    end
+    @list.should have(10).items
+  end
+
+end
+
+
+describe "Insertion into skiplist" do
+  
+  before(:each) do
+    @cut_level = 4
+    @list = Skiplist.new({}, nil, @cut_level)
+    @levels_list = []
+    (0..9).each do |i|
+      @list.insert("K#{i*10}", "V", x = rand(@cut_level-1)+1)
+      @levels_list << x
+    end
+  end
+
+  it "should return [self, nil] if not cut" do
+    a, b = @list.insert("K42", "L", @cut_level-1)
+    a.should == @list
+    b.should be_nil
+  end
+
+  it "should cut list by middle-entered value" do
+    a, b = @list.insert("K42", "H", @cut_level)
+    a.should == @list
+    b.should be_a_kind_of(Skiplist)
+    (0..4).each do |i|
+      chunks_should_have_separate_values(a, b, "K#{i*10}", "V")
+    end
+    chunks_should_have_separate_values(b, a, "K42", "H")
+    (5..9).each do |i|
+      chunks_should_have_separate_values(b, a, "K#{i*10}", "V")
+    end
+  end
+
+  def chunks_should_have_separate_values(a, b, a_key, a_value)
+    a.find(a_key).should == a_value
+    b.find(a_key).should == nil
+  end
+end
+
+=begin 
+random chunk writings, bad test. Come back to it in ChunkStore
+describe "Chunked skiplist process" do
+  
+  before(:all) do
+    @cut_level = 4
+    list = Skiplist.new({}, nil, @cut_level)
+    @lists = {list => 1}
+    n = ((1/Skiplist::PROBABILITY)**(@cut_level+2)).round
+    srand 12345
+    n.times do |i|
+      a, b = @lists.keys[rand(@lists.size)].insert(rand(100_000).to_s, "V")
+      @lists[a] = 1
+      @lists[b] = 1 if b
+    end
+    @lists = @lists.keys
+  end
+
+  it "should produce several chunks after many insertions" do
+    @lists.size.should > 1 
+  end
+    
+  # TODO: move to separate description with narrow assertions
+  it "should keep all the nodes except the first one on a lower level in each chunk" do
+    counted_first_node = false
+    @lists.each do |list|
+      cut_level = list.map{|node| node.level }.max
+      counted_cut = false
+      puts list.to_s_levels
+      puts "------"
+      if cut_level < @cut_level
+        #puts list
+        #puts "------- #{cut_level}"
+      end
+      if cut_level < @cut_level && !counted_first_node
+        counted_first_node = true
+      else
+        #cut_level.should >= @cut_level      
+      end
+      
+      list.each do |node|
+        unless counted_cut && node.level == cut_level
+          counted_cut = true
+        else
+          if node.level >= @cut_level
+            #puts list
+          end
+          #node.level.should < @cut_level
+        end
+      end
+    end
+  end
+
+end
+=end
+

data/spec/lib/strokedb/data_structures/inverted_list_spec.rb

@@ -0,0 +1,172 @@
+require File.dirname(__FILE__) + '/spec_helper'
+ 
+describe InvertedList, " with flat string attributes" do
+  
+  before(:all) do
+    @il = InvertedList.new
+    @oleg_profile   = new_doc('Profile', :name   => 'Oleg',
+                                         :email  => 'oleganza')
+    @yrashk_profile = new_doc('Profile', :name   => 'Yurii', 
+                                         :email  => 'yrashk')
+    @article1       = new_doc('Article', :title  => 'StrokeDB kicks ass', 
+                                         :author => ('@#' + @yrashk_profile[:uuid]))
+    @article2       = new_doc('Article', :title  => 'StrokeDB strikes back', 
+                                         :date   => '28 Jan 2008',
+                                         :author => ('@#' + @yrashk_profile[:uuid]))
+    @post1          = new_doc('Post',    :title  => 'Hello', 
+                                         :date   => '28 Jan 2008',
+                                         :author => ('@#' + @yrashk_profile[:uuid]))
+    
+    insert_doc(@il, @oleg_profile)
+    insert_doc(@il, @yrashk_profile)
+    insert_doc(@il, @article1)
+    insert_doc(@il, @article2)
+    insert_doc(@il, @post1)
+  end
+  
+  it "should find objects by a single attribute" do
+    @il.find(:name => 'Oleg').should == [@oleg_profile[:uuid]].to_set
+    @il.find(:email => 'yrashk').should == [@yrashk_profile[:uuid]].to_set
+    @il.find(:meta => 'Article').should == [@article1[:uuid], @article2[:uuid]].to_set
+    @il.find(:version => @article1[:slots][:version]).should == [@article1[:uuid]].to_set
+  end
+  
+  it "should not find object by a not matched attribute" do
+    @il.find(:name => 'Nobody').should == [  ].to_set
+    @il.find(:meta => 'NoMeta').should == [  ].to_set
+    @il.find(:version => 'no-version').should == [  ].to_set
+  end
+  
+  it "should find objects by a pair of attributes" do
+    @il.find(:date => '28 Jan 2008', :title => 'Hello').should == [@post1[:uuid]].to_set
+    @il.find(:date => '28 Jan 2008', :meta => 'Article').should == [@article2[:uuid]].to_set
+    @il.find(:date => '28 Jan 2008', :author => ('@#' + @yrashk_profile[:uuid])).should == [@post1[:uuid], @article2[:uuid]].to_set
+  end
+  
+  it "should not find objects by a not matched pair of attributes" do
+    @il.find(:date => '28 Jan 2008', :title => 'StrokeDB kicks ass').should == [  ].to_set
+    @il.find(:date => '28 Jan 2008', :meta => 'Profile').should == [  ].to_set
+    @il.find(:date => '28 Jan 2008', :author => ('@#' + @oleg_profile[:uuid])).should == [  ].to_set
+  end
+  
+  it "should find objects by three attributes" do
+    @il.find(:date     => '28 Jan 2008', 
+             :author   => ('@#' + @yrashk_profile[:uuid]),
+             :meta => 'Article'
+             ).should == [ @article2[:uuid] ].to_set
+  end
+  
+  it "should not find objects by not matched three attributes" do
+    @il.find(:date     => '28 Jan 2008', 
+             :author   => ('@#' + @oleg_profile[:uuid]),
+             :meta => 'Article'
+             ).should == [   ].to_set
+    @il.find(:date     => '42 Jan 2008', 
+             :author   => ('@#' + @yrashk_profile[:uuid]),
+             :meta => 'Article'
+             ).should == [   ].to_set
+    @il.find(:date     => '28 Jan 2008', 
+             :author   => ('@#' + @yrashk_profile[:uuid]),
+             :meta => 'Profile'
+             ).should == [   ].to_set
+  end
+  
+  it "should delete doc from index" do
+    @il.find(:name => 'Oleg').should == [@oleg_profile[:uuid]].to_set
+    delete_doc(@il, @oleg_profile)
+    @il.find(:name => 'Oleg').should == [  ].to_set
+    @il.find(:email => 'yrashk').should == [@yrashk_profile[:uuid]].to_set
+    delete_doc(@il, @yrashk_profile)
+    @il.find(:email => 'yrashk').should == [  ].to_set
+  end
+  
+end
+
+describe InvertedList, " with numeric attributes" do
+  
+  before(:all) do
+    @il = InvertedList.new
+    @ps = []
+    @ps << new_doc('Point', :x =>    0, :y =>  0)   # 0 
+    @ps << new_doc('Point', :x =>   10, :y =>  50)  # 1
+    @ps << new_doc('Point', :x =>   50, :y =>  50)  # 2
+    @ps << new_doc('Point', :x =>  200, :y =>  10)  # 3
+    @ps << new_doc('Point', :x =>  500, :y =>  10)  # 4
+    @ps << new_doc('Point', :x => -500, :y =>  10)  # 5
+    @ps << new_doc('Point', :x =>  -20, :y =>  10)  # 6
+    @ps << new_doc('Point', :x => -2.1, :y =>  10)  # 7
+    @ps << new_doc('Point', :x => 20.6, :y =>  10)  # 8
+    
+    @ps.each {|p| insert_doc(@il, p) }
+  end
+  
+  it "should find by positive value" do
+    @il.find(:x =>  10).should == [@ps[1][:uuid]].to_set
+    @il.find(:x =>  50).should == [@ps[2][:uuid]].to_set
+    @il.find(:x => 200).should == [@ps[3][:uuid]].to_set
+  end
+  
+  it "should find by negative value" do
+    @il.find(:x => -500).should == [@ps[5][:uuid]].to_set
+    @il.find(:x =>  -20).should == [@ps[6][:uuid]].to_set
+  end
+
+  it "should find by zero value" do
+    @il.find(:x => 0).should == [@ps[0][:uuid]].to_set
+  end
+  
+  # Dangerous: 2.1 may suddenly appear as 2.0999999999996235 or like that
+  it "should find by float value" do
+    @il.find(:x => -2.1).should == [@ps[7][:uuid]].to_set
+    @il.find(:x => 20.6).should == [@ps[8][:uuid]].to_set
+  end
+  
+end
+=begin
+describe InvertedList, " with multivalue slots" do
+  before(:all) do
+    @il = InvertedList.new
+    @ab   = new_doc(%w[A B])
+    @a    = new_doc(%w[A])
+    @b    = new_doc(%w[B])
+    @c    = new_doc(%w[C])
+    insert_doc(@il, @ab)
+    insert_doc(@il, @a)
+    insert_doc(@il, @b)
+    insert_doc(@il, @c)
+  end
+  
+  it "should find multivalue objects by a single value" do
+    @il.find(:meta => proc{|v| v.include? 'A' }).should == [@a[:uuid], @ab[:uuid]].to_set
+    @il.find(:meta => proc{|v| v.include? 'B' }).should == [@b[:uuid], @ab[:uuid]].to_set
+  end
+  
+  it "should not find by scalar value" do
+    @il.find(:meta => 'A').should == [ ].to_set
+    @il.find(:meta => 'B').should == [ ].to_set
+  end
+  
+  it "should find multivalue objects with a complex predicate" do
+    @il.find(:meta => proc{|v| v.include?('A') && !v.include?('B') }).should == [@a[:uuid]].to_set
+    @il.find(:meta => proc{|v| v.include?('A') || v.include?('B') }).should == 
+      [@a[:uuid], @ab[:uuid], @b[:uuid]].to_set
+    @il.find(:meta => proc{|v| v.include?('A') && v.include?('B') }).should == [@ab[:uuid]].to_set
+  end
+end
+=end
+
+
+def new_doc(meta, slots = {})
+  slots[:meta] = meta
+  slots[:version] = 'v1' + rand(10000000).to_s
+  {:uuid => meta.to_s + '-' + rand(1000000).to_s, :slots => slots}
+end
+
+def insert_doc(il, doc)
+  il.insert(doc[:slots], doc[:uuid])
+end
+
+def delete_doc(il, doc)
+  il.delete(doc[:slots], doc[:uuid])
+end
+