strokedb 0.0.2.1 → 0.0.2.2

data/script/console

@@ -1,70 +1,2 @@
-#! /usr/bin/env ruby
-
-$:.unshift File.dirname(__FILE__)
-
-require 'irb'
-require 'pp'
-require "strokedb"
-include StrokeDB
-
-Doc = Document
-
-def save!
-  StrokeDB.default_store.chunk_storage.sync_chained_storages!
-  true
-  "Database has been saved."
-end
-
-def build_config
-  StrokeDB::Config.build :default => true, :base_path => '.console.strokedb'
-  true
-end
-
-def clear!
-  FileUtils.rm_rf '.console.strokedb'
-  build_config
-  "Database has been wiped out."
-end
-
-def find(*args)
-  StrokeDB.default_store.find(*args)
-end
-
-def store
-  StrokeDB.default_store
-end
-
-def h(*args)
-  puts %{
-    Commands:
-    
-    clear!      -- Clear the database (will erase all data in console's store)
-    save!       -- Save database (if you will quit without it, your changes will not be recorded)
-    find <uuid> -- Find document by UUID (example: find "a4430ff1-6cb4-4428-a292-7ab8b77de467")
-    
-    Aliases:
-    
-    Doc         -- StrokeDB::Document
-    store       -- current store
-  }
-end
-
-def reload!
-  silence_warnings do
-    load "strokedb.rb"
-  end
-  "Classes reloaded."
-end
-
-if ARGV.last.is_a?(String) && File.exists?(ARGV.last+'/config')
-  StrokeDB::Config.load(ARGV.last+'/config',true)
-  puts "# loading #{ARGV.last}"
-  ARGV.pop
-else
-  build_config
-end
-
-puts "StrokeDB #{StrokeDB::VERSION} Console"
-puts "Type 'h' for help"
-
-IRB.start
+#!/bin/sh
+bin/strokedb $*

data/spec/integration/remote_store_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/spec_helper'
+=begin
+class RemoteStoreContext
+  def initialize(store)
+    @user = Meta.new store, :name => "User"
+  end
+  def create_user(*args)
+    @user.create!(*args)
+  end
+  def find_users
+    @user.find
+  end
+end
+
+class ClientScenario < RemoteStoreContext 
+  def initialize
+    @store = StrokeDB::RemoteStore::Client.new('127.0.0.1', 4440)
+    super(@store)
+  end
+end
+
+class ServerScenario < RemoteStoreContext 
+  def initialize
+    StrokeDB::Config.build :default => true, :base_path => '../temp/storages/drb_store'
+    StrokeDB.default_store.remote_server("0.0.0.0", 4540).start
+    super(StrokeDB.default_store)
+  end
+end
+Thread.abort_on_exception = true
+server_thread = Thread.new{ Thread.current['s'] = ServerScenario.new }
+client_thread = Thread.new{ Thread.current['s'] = ClientScenario.new }
+
+sleep 2
+p server_thread['s'].create_user(:name => "server guy")
+exit!
+
+describe "Database operations thru remote_store" do
+
+  it "should work perfectly" do
+    # Start scenarios
+    client = $client
+    server = $server
+    
+    # 1. Store document on a server
+    server.create_user(:name => "server guy").name.should == 'server guy'
+    server.find_users.size.should == 1
+    server.find_users[0].name.should == 'server guy'
+    
+    # 2. Find server's documents in a client
+    client.find_users.size.should == 1
+    server.find_users[0].name.should == 'server guy'
+    
+    # 3. Store document on a client
+    client.create_user(:name => "client guy").name.should == 'client guy'
+    
+    # 4. Find all the documents on a server
+    server.find_users.size.should == 2
+    server.find_users[0].name.should == 'server guy'
+    server.find_users[1].name.should == 'client guy'
+    
+    # 5. Find all documents in a client
+    client.find_users.size.should == 2
+    client.find_users[0].name.should == 'server guy'
+    client.find_users[1].name.should == 'client guy'
+  end
+
+end  
+  
+=end
+

data/spec/integration/search_spec.rb

@@ -0,0 +1,76 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Database search" do
+  
+  before(:all) do
+    @path = File.dirname(__FILE__) + "/../temp/storages/database_search"
+    FileUtils.rm_rf @path
+    @f_storage = FileStorage.new(:path => @path + "/storage")
+    @f_storage.clear!
+    @index_storage = InvertedListFileStorage.new(:path => @path+"/index")
+    @index_storage.clear!
+    @index  = InvertedListIndex.new(@index_storage)
+    @index2 = InvertedListIndex.new(@index_storage)
+    
+    @f_store = Store.new(:storage => @f_storage, :index => @index, :path => @path + '/store')
+    @index.document_store = @f_store
+    @index2.document_store = @f_store
+    
+    @profile_meta = Document.create!(@f_store, :name => 'Profile', 
+                                               :non_indexable_slots => [ :bio, :version, :previous_version ])
+  end
+  
+  # Leave for investigation
+  # after(:all) do
+  #   FileUtils.rm_rf @path
+  # end
+  
+  it "should add new doc" do
+    doc = Document.create!(@f_store, :name => "Oleg", :state => 'Russia', :age => 21, :meta => @profile_meta)
+    doc.uuid.should_not be_nil
+    @oleg_uuid = doc.uuid
+    results = @index.find(:name => "Oleg")
+    results.should_not be_empty
+    results[0].uuid.should == @oleg_uuid
+  end
+  
+  it "should find doc in a separate index instance" do
+    results = @index2.find(:name => "Oleg", :meta => @profile_meta)
+    results.should_not be_empty
+    results[0]["name"].should == "Oleg"
+  end
+  
+  it "should store & find several docs" do
+    doc = Document.create!(@f_store, :name => "Yurii", :state => 'Ukraine', :meta => @profile_meta)
+    doc.save!
+    @yura_uuid = doc.uuid
+    results = @index.find(:name => "Yurii")
+    results.should_not be_empty
+    results[0].uuid.should == @yura_uuid
+  end
+
+  it "should find all profiles" do
+    results = @index.find(:meta => @profile_meta)
+    results.should_not be_empty
+    results.map{|e| e.uuid}.to_set == [ @yura_uuid, @oleg_uuid ].to_set 
+  end
+  
+  it "should find all profiles from Ukraine" do
+    results = @index.find(:meta => @profile_meta, :state => 'Ukraine')
+    results.should_not be_empty
+    results.map{|e| e.uuid}.to_set == [ @yura_uuid ].to_set 
+  end
+  
+  it "should remove info from index" do
+    results = @index.find(:name => 'Oleg')
+    oleg = results[0]
+    oleg[:name] = 'Oleganza'
+    oleg.save!
+    results = @index.find(:name => 'Oleg')
+    results.should be_empty
+    results = @index.find(:name => 'Oleganza')
+    results[0].uuid.should == oleg.uuid
+  end
+  
+end
+

data/spec/integration/spec_helper.rb

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

data/spec/lib/spec_helper.rb

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

data/spec/lib/strokedb/config_spec.rb

@@ -0,0 +1,250 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Config" do
+
+  before(:each) do
+    @config = StrokeDB::Config.new
+    @root_path = TEMP_STORAGES + '/config/'
+    @paths = []
+  end
+  
+  it "should be the default config if desired" do
+    @config = StrokeDB::Config.new(true)
+    ::StrokeDB.default_config.should == @config
+  end
+  
+  it "should have no storages or indexes on creation" do
+    @config.storages.should be_empty
+    @config.indexes.should be_empty
+  end
+  
+  it "should add known storages without specific parameters" do
+    @config.add_storage :mem, :memory
+    @config.storages[:mem].should be_an_instance_of(MemoryStorage)
+  end
+
+  it "should add known storages with specific parameters" do
+    @paths << (@root_path + "file_storage")
+    @config.add_storage :fs, :file, :path => @paths.last
+    @config.storages[:fs].should be_an_instance_of(FileStorage)
+    @config.storages[:fs].path.should == @paths.last
+  end
+  
+  it "should raise the correct exception when adding an unknown storage" do
+    lambda { @config.add_storage :unknown, :unknown_storage_type }.should raise_error(StrokeDB::UnknownStorageTypeError)
+  end
+  
+  it "should raise an exception on chain with insufficient storages" do
+    lambda { @config.chain }.should raise_error
+    @config.add_storage :mem, :memory
+    lambda { @config.chain :mem }.should raise_error
+  end
+
+  it "should raise an exception on chain with undefined storages" do
+    lambda { @config.chain :not_here }.should raise_error
+  end
+
+  it "should chain storages together" do
+    @paths << (@root_path + "file_storage_chain")
+    @config.add_storage :mem1, :memory
+    @config.add_storage :mem2, :memory
+    @config.add_storage :mem3, :memory
+    @config.add_storage :fs, :file, :path => @paths.last
+    @config.chain :mem1, :mem2, :fs
+    @config.chain :mem2, :mem3
+    @config.storages[:mem1].should have_chained_storage(@config.storages[:mem2])
+    @config.storages[:mem2].should have_chained_storage(@config.storages[:fs])
+    @config.storages[:fs].should have_chained_storage(@config.storages[:mem2])
+    @config.storages[:mem2].should have_chained_storage(@config.storages[:mem1])
+    @config.storages[:mem1].should_not have_chained_storage(@config.storages[:mem1])
+    @config.storages[:mem2].should_not have_chained_storage(@config.storages[:mem2])
+    @config.storages[:fs].should_not have_chained_storage(@config.storages[:fs])
+    @config.storages[:mem1].should_not have_chained_storage(@config.storages[:fs])
+    @config.storages[:fs].should_not have_chained_storage(@config.storages[:mem1])
+    @config.storages[:mem2].should have_chained_storage(@config.storages[:mem3])
+    @config.storages[:mem3].should have_chained_storage(@config.storages[:mem2])
+    @config.storages[:mem1].should_not have_chained_storage(@config.storages[:mem3])
+    @config.storages[:fs].should_not have_chained_storage(@config.storages[:mem3])
+  end
+
+  it "should add an index" do
+    @paths << (@root_path + "file_storage_index")
+    @config.add_storage :fs, :file, :path => @paths.last
+    @paths << (@root_path + "inverted_list_file_index")
+    @config.add_storage :idx_st, :inverted_list_file, :path => @paths.last
+    @config.add_index :idx, :inverted_list, :idx_st
+    @config.indexes[:idx].should be_an_instance_of(InvertedListIndex)
+  end
+
+  it "should raise the correct exception when adding an unknown index" do
+    lambda { @config.add_index :unknown, :unknown_index_type, :idx_st }.should raise_error(StrokeDB::UnknownIndexTypeError)
+  end
+
+  it "should add a store" do
+    @paths << (@root_path + "file_storage")
+    @config.add_storage :fs, :file, :path => @paths.last
+    @config.add_store :store, nil, :storage => :fs, :cut_level => 4, :path => @paths.last
+    @config.stores[:store].should be_an_instance_of(Store)
+    @config.stores[:store].storage.should == @config.storages[:fs]
+  end
+  
+  it "should add a default store with default index" do
+    @paths << (@root_path + "file_storage_default_index")
+    @config.add_storage :fs, :file, :path => @paths.last
+    @paths << (@root_path + "inverted_list_file_default_index")
+    @config.add_storage :index_storage, :inverted_list_file, :path => @paths.last
+    @config.add_index :default, :inverted_list, :index_storage
+    @config.add_store :default, nil, :storage => :fs, :cut_level => 4, :path => @paths.last
+    @config.stores[:default].should be_an_instance_of(Store)
+    @config.indexes[:default].document_store.should == @config.stores[:default]
+  end
+
+  after(:each) do
+    @paths.each {|path| FileUtils.rm_rf path}
+  end
+
+end
+
+describe "Config builder" do
+  
+  before(:each) do
+    @base_path = TEMP_STORAGES + '/cfg_builder'
+    FileUtils.rm_rf @base_path
+  end
+
+  after(:each) do
+    FileUtils.rm_rf @base_path
+  end
+  
+  it "should make config default if told so" do
+    config = StrokeDB::Config.build :default => true, :base_path => @base_path
+    StrokeDB.default_config.should == config
+  end
+
+  it "should not make config default if told so" do
+    config = StrokeDB::Config.build :base_path => @base_path
+    StrokeDB.default_config.should_not == config
+  end
+  
+  it "should use Store by default" do
+    config = StrokeDB::Config.build :base_path => @base_path
+    config.stores[:default].should be_a_kind_of(Store)
+  end
+
+  it "should use specified store if told so" do
+    StrokeDB.send!(:remove_const,'SomeFunnyStore') if defined?(SomeFunnyStore)
+    StrokeDB::SomeFunnyStore = Class.new(Store)
+    config = StrokeDB::Config.build :store => :some_funny, :base_path => @base_path
+    config.stores[:default].should be_a_kind_of(SomeFunnyStore)
+  end
+
+  it "should add storages as he is told to" do
+    StrokeDB.send!(:remove_const,'Chunk1Storage') if defined?(Chunk1Storage)
+    StrokeDB.send!(:remove_const,'Chunk2Storage') if defined?(Chunk2Storage)
+    StrokeDB::Chunk1Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk2Storage = Class.new(MemoryStorage)
+    config = StrokeDB::Config.build :storages => [:chunk_1,:chunk_2], :base_path => @base_path
+    config.storages[:chunk_1].should be_a_kind_of(Chunk1Storage)
+    config.storages[:chunk_2].should be_a_kind_of(Chunk2Storage)
+  end
+  
+  it "should initialize all storages with base_path+storage_name" do
+    StrokeDB.send!(:remove_const,'Chunk1Storage') if defined?(Chunk1Storage)
+    StrokeDB.send!(:remove_const,'Chunk2Storage') if defined?(Chunk2Storage)
+    StrokeDB::Chunk1Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk2Storage = Class.new(MemoryStorage)
+    Chunk1Storage.should_receive(:new).with(:path => @base_path + '/chunk_1').and_return(MemoryStorage.new)
+    Chunk2Storage.should_receive(:new).with(:path => @base_path + '/chunk_2').and_return(MemoryStorage.new)
+    config = StrokeDB::Config.build :storages => [:chunk_1,:chunk_2], :base_path => @base_path
+  end
+  
+  it "should add :memory and :file by default" do
+    config = StrokeDB::Config.build :base_path => @base_path
+    config.storages[:memory].should be_a_kind_of(MemoryStorage)
+    config.storages[:file].should be_a_kind_of(FileStorage)
+  end
+
+  it "should chain given storages sequentially" do
+    StrokeDB.send!(:remove_const,'Chunk1Storage') if defined?(Chunk1Storage)
+    StrokeDB.send!(:remove_const,'Chunk2Storage') if defined?(Chunk2Storage)
+    StrokeDB.send!(:remove_const,'Chunk3Storage') if defined?(Chunk3Storage)
+    StrokeDB::Chunk1Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk2Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk3Storage = Class.new(MemoryStorage)
+    config = StrokeDB::Config.build :storages => [:chunk_1,:chunk_2,:chunk_3], :base_path => @base_path
+    config.storages[:chunk_1].should have_chained_storage(config[:chunk_2])
+    config.storages[:chunk_2].should have_chained_storage(config[:chunk_1])
+    config.storages[:chunk_3].should have_chained_storage(config[:chunk_2])
+    config.storages[:chunk_2].should have_chained_storage(config[:chunk_3])
+  end
+
+  it "should set authoritative sources for storages sequentially" do
+    StrokeDB.send!(:remove_const,'Chunk1Storage') if defined?(Chunk1Storage)
+    StrokeDB.send!(:remove_const,'Chunk2Storage') if defined?(Chunk2Storage)
+    StrokeDB.send!(:remove_const,'Chunk3Storage') if defined?(Chunk3Storage)
+    StrokeDB::Chunk1Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk2Storage = Class.new(MemoryStorage)
+    StrokeDB::Chunk3Storage = Class.new(MemoryStorage)
+    config = StrokeDB::Config.build :storages => [:chunk_1,:chunk_2,:chunk_3], :base_path => @base_path
+    config.storages[:chunk_1].authoritative_source.should == config[:chunk_2]
+    config.storages[:chunk_2].authoritative_source.should == config[:chunk_3]
+    config.storages[:chunk_3].authoritative_source.should be_nil
+  end
+  
+  it "should use InvertedListIndex by default" do
+    config = StrokeDB::Config.build :base_path => @base_path
+    config.indexes[:default].should be_a_kind_of(InvertedListIndex)
+  end
+
+  it "should use specific index if told so by default" do
+    StrokeDB.send!(:remove_const,'SomeFunnyIndex') if defined?(SomeFunnyIndex)
+    StrokeDB::SomeFunnyIndex = Class.new(InvertedListIndex)
+    config = StrokeDB::Config.build :index => :some_funny, :base_path => @base_path
+    config.indexes[:default].should be_a_kind_of(SomeFunnyIndex)
+  end
+
+  it "should use InvertedListFileStorage index storage by default" do
+    config = StrokeDB::Config.build :base_path => @base_path
+    config.storages[:inverted_list_file].should be_a_kind_of(InvertedListFileStorage)
+  end
+
+  it "should use specific index storage if told so" do
+    StrokeDB.send!(:remove_const,'SomeFunnyIndexStorage') if defined?(SomeFunnyIndexStorage)
+    StrokeDB::SomeFunnyIndexStorage = Class.new(InvertedListFileStorage)
+    config = StrokeDB::Config.build :index_storages => [:some_funny_index], :base_path => @base_path
+    config.storages[:some_funny_index].should be_a_kind_of(SomeFunnyIndexStorage)
+  end
+
+  it "should initialize index storage with base_path+storage_name" do
+    StrokeDB.send!(:remove_const,'SomeFunnyIndexStorage') if defined?(SomeFunnyIndexStorage)
+    StrokeDB::SomeFunnyIndexStorage = Class.new(InvertedListFileStorage)
+    index_storage = StrokeDB::SomeFunnyIndexStorage.new(:path => @base_path + '/some_funny_index')
+    SomeFunnyIndexStorage.should_receive(:new).with(:path => @base_path + '/some_funny_index').and_return(index_storage)
+    config = StrokeDB::Config.build :index_storages => [:some_funny_index], :base_path => @base_path
+  end
+
+  it "should dump config in base_path (except 'default' key)" do
+    cfg = StrokeDB::Config.build :default => true, :base_path => @base_path
+    config = JSON.parse(IO.read(@base_path + '/config'))
+    config.should == cfg.build_config
+  end
+
+  it "should load dumped config" do
+    cfg = StrokeDB::Config.build :default => true, :base_path => @base_path
+    cfg.storages.values.each {|s| s.close! if s.respond_to?(:close!)}
+    config = JSON.parse(IO.read(@base_path + '/config'))
+    cfg = StrokeDB::Config.load(@base_path + '/config')
+    cfg.build_config.should == config
+    cfg.should_not == StrokeDB.default_config
+  end
+  
+  it "should load dumped config and make it default if told so" do
+    cfg = StrokeDB::Config.build :default => true, :base_path => @base_path
+    cfg.storages.values.each {|s| s.close! if s.respond_to?(:close!)}
+    config = JSON.parse(IO.read(@base_path + '/config'))
+    cfg = StrokeDB::Config.load(@base_path + '/config',true)
+    cfg.build_config.should == config
+    cfg.should == StrokeDB.default_config
+  end
+    
+end