rod 0.6.1 → 0.6.2

data/tests/migration_model1.rb

@@ -0,0 +1,23 @@
+require 'rod'
+
+class Database < Rod::Database
+end
+
+class Model < Rod::Model
+  database_class Database
+end
+
+class User < Model
+  field :name, :string, :index => :flat
+  field :surname, :string
+  has_one :account, :index => :flat
+  has_many :files, :index => :flat, :class_name => "UserFile"
+end
+
+class Account < Model
+  field :login, :string
+end
+
+class UserFile < Model
+  field :data, :string
+end

data/tests/migration_model2.rb

@@ -0,0 +1,27 @@
+require 'rod'
+
+class Database < Rod::Database
+end
+
+class Model < Rod::Model
+  database_class Database
+end
+
+class User < Model
+  field :name, :string, :index => :flat
+  field :age, :integer
+  has_one :account, :index => :flat
+  has_many :files, :index => :flat, :class_name => "UserFile"
+  has_many :accounts, :index => :flat
+end
+
+class Account < Model
+  field :login, :string
+  field :password, :string
+end
+
+class UserFile < Model
+  field :data, :string
+  field :name, :string, :index => :flat
+end
+

data/tests/migration_verify.rb

@@ -0,0 +1,56 @@
+$:.unshift("lib")
+require 'rod'
+require 'rspec/expectations'
+require File.join(".",File.dirname(__FILE__),"migration_model2")
+
+Rod::Database.development_mode = true
+
+Database.instance.open_database("tmp/migration")
+
+user = User[0]
+user.should_not == nil
+user = User.find_by_name("John")
+user.should_not == nil
+user.name.should == "John"
+user.age.should == 0
+user.account.should_not == nil
+user.account.should == Account[0]
+user.files.size.should == 3
+user.accounts.size.should == 1
+user.accounts[0].should == user.account
+
+account = Account[0]
+account.login.should == "john"
+account.password.should == ""
+User.find_all_by_account(account).size.should == 1
+User.find_all_by_account(account)[0].should == user
+User.find_by_account(account).should_not == nil
+user.account.should == account
+
+user = User.find_by_name("Amanda")
+user.should_not == nil
+user.name.should == "Amanda"
+user.age.should == 0
+user.account.should_not == nil
+user.files.size.should == 5
+user.accounts.size.should == 1
+user.accounts[0].should == user.account
+
+account = Account[1]
+account.login.should == "amanda"
+account.password.should == ""
+User.find_by_account(account).should_not == nil
+user.account.should == account
+
+file = UserFile[0]
+file.data.should == "0 data"
+
+UserFile.each do |file|
+  file.data.should_not == nil
+  file.name.should == ""
+end
+users = User.find_all_by_files(file)
+users.size.should == 2
+users[1].should == user
+
+Database.instance.close_database

data/tests/mock_tests.rb

@@ -0,0 +1,128 @@
+$:.unshift("lib")
+
+require 'rod'
+require 'test/unit'
+require 'mocha'
+
+module RodTest
+  class InnerExporter < Rod::Exporter
+  end
+
+  class InnerLoader < Rod::Loader
+  end
+
+  class Exporter
+    def self.method_missing(method_sym, *arguments)
+      arguments_str = ""
+      #     begin
+      arguments_str = arguments.to_s
+      #     rescue TypeError
+      # empty is ok - thrown when trying to access fields too early
+      #     end
+      puts "EX: static #{method_sym.to_s} (#{arguments_str})"
+      InnerExporter.send(method_sym, *arguments)
+    end
+  end
+
+  class Loader
+    def self.method_missing(method_sym, *arguments)
+      arguments_str = arguments.to_s
+      puts "LD: static #{method_sym.to_s} (#{arguments_str})"
+      InnerLoader.send(method_sym, *arguments)
+    end
+  end
+
+  class Database < Rod::Database
+  end
+
+  class Model < Rod::Model
+    attr_accessor :used
+    database_class Database
+  end
+
+  class BStruct < Model
+    field :b, :string
+    has_one :a_struct
+
+    def to_s
+      "#{self.b}"
+    end
+
+  end
+
+  class AStruct < Model
+    field :a1, :integer
+    field :a2, :ulong, :index => true
+    has_many :b_structs, :class_name => "RodTest::BStruct"
+
+    #	  def to_s    <- causes strange Error - see Exporter::method_missing
+    #		  "#{a1}, #{a2}"
+    #  	end
+  end
+
+  class ModuleTests < Test::Unit::TestCase
+
+    MAGNITUDE = 5
+    TEST_FILENAME = "tmp/db"
+
+    def setup
+      @as = Array.new
+      @bs = Array.new
+
+      (0..MAGNITUDE).each do |j|
+        @as[j] = AStruct.new
+        @as[j].a1 = j
+        @as[j].a2 = j * 10000
+      end
+
+      (0..MAGNITUDE).each do |j|
+        @bs[j] = BStruct.new
+        @bs[j].b = "string_#{j}"
+        @bs[j].a_struct = @as[j]
+      end
+
+      #     (0..MAGNITUDE).each do |j|
+      #        @as[j].b_structs = @bs[j .. ((j+1) % MAGNITUDE)]
+      #      end
+    end
+
+    def teardown
+      begin
+        RodTest::Database.instance.close_database
+      rescue RuntimeError
+        #ok, because of mocking store subroutines not all references are marked as stored
+      end
+    end
+
+    def test_store
+      puts
+
+      Database.instance.create_database("#{TEST_FILENAME}2")
+
+      Database.instance.expects(:_store_rod_test__a_struct).times(6)
+      Database.instance.expects(:_store_rod_test__b_struct).times(6)
+      @as.each do |a|
+        a.store
+      end
+      @bs.each do |b|
+        b.store
+      end
+    end
+
+    def test_create
+      puts
+
+      Database.instance..expects(:create)
+      Database.instance.create_database("#{TEST_FILENAME}3")
+    end
+
+    def test_close
+      puts
+
+      Database.instance.create_database("#{TEST_FILENAME}4")
+      Exporter.instance.expects(:close)
+      Database.instance.close_database()
+    end
+
+  end
+end

data/tests/read_on_create.rb

@@ -0,0 +1,45 @@
+$:.unshift("tests")
+require 'structures'
+require 'validate_read_on_create'
+
+puts "-- Read data while creating DB --"
+Rod::Database.development_mode = true
+
+
+RodTest::Database.instance.create_database("tmp/read_write")
+my_structures = []
+MAGNITUDO.times do |index|
+  your_struct = RodTest::YourStruct.new
+  your_struct.counter = index
+  your_struct.title = "Title_#{index}"
+  your_struct.store
+
+  my_struct = RodTest::MyStruct.new
+  my_struct.count = index
+  my_struct.your_struct = your_struct
+  my_struct.title = "Title_#{index}"
+  my_struct.title2 = "Title2_#{index}"
+
+  my_struct.store
+  my_structures << my_struct
+end
+
+MAGNITUDO.times do |index|
+  # validate object fetched from cache
+  struct = RodTest::MyStruct[index]
+  validate(index,struct)
+  # validate object referenced previously
+  validate(index,my_structures[index])
+  # validate referential integrity
+  if struct.object_id != my_structures[index].object_id
+    raise "Object stored and recived are different #{struct.object_id} " +
+      "#{my_structures[index].object_id}"
+  end
+  if struct != my_structures[index]
+    raise "Object stored and recived are different #{struct} " +
+      "#{my_structures[index]}"
+  end
+end
+
+
+RodTest::Database.instance.close_database

data/tests/save_struct.rb

@@ -0,0 +1,49 @@
+$:.unshift("tests")
+require 'structures'
+
+puts "-- Save sample structures test --"
+Rod::Database.development_mode = true
+RodTest::Database.instance.create_database("tmp/abc")
+
+#MAGNITUDE = 100000
+MAGNITUDE = 50
+
+his = []
+(MAGNITUDE * 10).times do |i|
+  his[i] = RodTest::HisStruct.new
+  his[i].inde = i
+end
+
+ys = []
+(MAGNITUDE * 1).times do |i|
+  ys[i] = RodTest::YourStruct.new
+  ys[i].counter = 10
+  ys[i].his_structs = his[i*10...(i+1)*10]
+end
+
+ms = []
+(MAGNITUDE * 1).times do |i|
+  ms[i] = RodTest::MyStruct.new
+  ms[i].count = 10 * i
+  ms[i].precision = 0.1 * i
+  ms[i].identifier = i
+  ms[i].your_struct = ys[i]
+  ms[i].title = "title_#{i}"
+  ms[i].title2 = "title2_#{i}"
+  ms[i].body = "body_#{i}"
+end
+
+RodTest::Database.instance.print_layout
+ms.each_with_index{|s,i|
+  begin
+    puts i if i % 1000 == 0
+    s.store
+  rescue Exception => e
+    puts e
+    raise
+  end
+}
+ys.each{|y| y.store}
+his.each{|h| h.store}
+RodTest::Database.instance.print_layout
+RodTest::Database.instance.close_database

data/tests/structures.rb

@@ -0,0 +1,52 @@
+$:.unshift("lib")
+require 'rod'
+
+module RodTest
+  class Database < Rod::Database
+  end
+
+  class Model < Rod::Model
+    database_class Database
+  end
+
+  class MyStruct < Model
+    field :count, :integer
+    field :precision, :float
+    field :identifier, :ulong
+    field :title, :string, :index => :segmented
+    field :title2, :string
+    field :body, :string
+    has_one :your_struct
+
+    def to_s
+      "#{self.title} #{self.body} " +
+        "count #{self.count}, precision #{self.precision}, " +
+        "identifier #{self.identifier} rod_id #{self.rod_id} " +
+        "your_struct #{self.your_struct}"
+    end
+  end
+
+  class YourStruct < Model
+    field :counter, :integer
+    field :title, :string
+    has_many :his_structs
+    has_many :her_structs, :class_name => "RodTest::HisStruct"
+
+    def to_s
+      "counter #{self.counter}, title #{self.title} his structs " +
+        "#{self.his_structs.map{|e| e.inde}.join("")}"
+    end
+  end
+
+  class HisStruct < Model
+    field :inde, :integer
+
+    def to_s
+      "inde #{self.inde}"
+    end
+
+    def inspect
+      self.to_s
+    end
+  end
+end

data/tests/unit/database.rb

@@ -0,0 +1,60 @@
+$:.unshift("lib")
+require 'test/unit'
+require 'rod'
+
+class DatabaseTest < Test::Unit::TestCase
+  def setup
+    @database = Rod::Database.instance
+    @database.create_database("tmp/unit_database")
+  end
+
+  def teardown
+    @database.close_database
+  end
+
+  def test_version_validity
+    Rod::VERSION.sub!(/.*/,"0.1.0")
+    file = "0.1.0"
+    assert(@database.send(:valid_version?,file))
+
+    Rod::VERSION.sub!(/.*/,"0.1.1")
+    file = "0.1.0"
+    assert(not(@database.send(:valid_version?,file)))
+
+    Rod::VERSION.sub!(/.*/,"0.2.1")
+    file = "0.2.0"
+    assert(@database.send(:valid_version?,file))
+
+    Rod::VERSION.sub!(/.*/,"0.2.0")
+    file = "0.2.1"
+    assert(!@database.send(:valid_version?,file))
+  end
+
+  def test_created_at
+    assert(Time.now - @database.metadata["Rod"][:created_at] < 10)
+  end
+
+  def test_updated_at
+    sleep(1)
+    @database.close_database
+    @database.open_database("tmp/unit_database",false)
+    assert(@database.metadata["Rod"][:updated_at] -
+           @database.metadata["Rod"][:created_at] >= 1)
+    assert(@database.metadata["Rod"][:updated_at] -
+           @database.metadata["Rod"][:created_at] < 4)
+    sleep(2)
+    @database.close_database
+    @database.open_database("tmp/unit_database",false)
+    assert(@database.metadata["Rod"][:updated_at] -
+           @database.metadata["Rod"][:created_at] >= 3)
+    assert(@database.metadata["Rod"][:updated_at] -
+           @database.metadata["Rod"][:created_at] < 6)
+  end
+
+  def test_superclass
+    @database.close_database
+    @database.open_database("tmp/unit_database")
+    assert(@database.metadata["Rod::StringElement"][:superclass] ==
+           Rod::AbstractModel.name)
+  end
+end