ObjectModel 0.3.0

data/spec/cascade_delete_spec.rb

@@ -0,0 +1,168 @@
+require 'ObjectModel/require'
+require 'spec'
+
+module ObjectModel
+	module CascadeDelete
+		describe "Events" do
+			class CompositeEntity
+				inherit Entity
+				metadata do
+					child :child
+					child :children, :bag
+				end
+			end								
+			
+			class EnityDeleteAllChildren
+				inherit Entity
+				metadata do
+					child :child
+					child :child2
+				end
+			end								
+			
+			it "Shouldn't allow to assign non-Entities to Children" do
+				lambda{
+					@r.transaction{
+						@r['e'].child = "string"
+					}.commit
+				}.should raise_error(/Child should be Entity or Nil/)
+				
+				lambda{
+					@r.transaction{
+						@r['e'].children << "string"
+					}.commit
+				}.should raise_error(/Child should be Entity or Nil/)
+			end
+			
+			it "Shouldn't allow to assign self as Child" do
+				lambda{
+					@r.transaction{
+						entity = @r['e']
+						entity.child = entity
+					}.commit
+				}.should raise_error(/Forbiden to add self as Child/)
+			end
+			
+			it "Shouldn't allow to assign the same Child twice (for the same Entity)" do
+				lambda{
+					@r.transaction{
+						entity = @r['e']
+						child = CompositeEntity.new 'child'
+						entity.child = child
+						entity.children << child
+					}.commit
+				}.should raise_error(/Forbiden to add the same Child twice/)
+			end
+			
+			it "Delete should delete Entity from it's Parent Childrens" do
+				@r.transaction{
+					p = CompositeEntity.new 'parent'
+					
+					c1 = CompositeEntity.new 'child1'
+					c2 = CompositeEntity.new 'child2'
+					
+					p.child = c1
+					p.children << c2
+				}.commit
+				
+				@r.transaction{
+					@r['parent/child1'].delete
+					@r['parent/child2'].delete
+				}.commit					
+				
+				@r['parent'].child.should be_nil
+				@r['parent'].children.should be_empty					
+			end								
+			
+			it "Should also delete all Children for_deleted Entity" do
+				@r.transaction{
+					p = CompositeEntity.new 'parent'
+					
+					c1 = CompositeEntity.new 'child1'
+					c2 = CompositeEntity.new 'child2'
+					
+					p.child = c1
+					p.children << c2
+				}.commit
+				
+				@r.should_not include('child1')
+				@r.should_not include('child2')
+				
+				@r.transaction{
+					@r['parent'].delete
+				}.commit
+				
+				@r.should_not include('parent')
+				@r.should_not include('child1')
+				@r.should_not include('child2')
+				@r.should_not include('parent/child1')
+				@r.should_not include('parent/child1')
+			end
+			
+			it "Should also delete all Children Entity (from error)" do
+				@r.transaction{
+					p = EnityDeleteAllChildren.new 'parent'
+					
+					c1 = EnityDeleteAllChildren.new 'child1'
+					c2 = EnityDeleteAllChildren.new 'child2'
+					
+					p.child = c1
+					p.child2 = c2
+				}.commit
+				
+				@r.transaction{
+					@r['parent'].delete
+				}.commit
+				
+				@r.should_not include('child1')
+				@r.should_not include('child2')
+				@r.should_not include('parent/child1')
+				@r.should_not include('parent/child1')
+			end
+			
+			it "Deleting Child from Children should also delete Child.parent but not delete Child themself" do
+				@r.transaction{
+					p = CompositeEntity.new 'parent'
+					
+					c1 = CompositeEntity.new 'child1'
+					c2 = CompositeEntity.new 'child2'
+					
+					p.child = c1
+					p.children << c2
+				}.commit
+				
+				tr = @r.transaction{
+					p = @r['parent']
+					p.child = nil
+					p.children.clear
+				}
+				@r['parent'].child.should_not be_nil
+				@r['parent/child1'].parent.should_not be_nil
+				@r['parent/child2'].parent.should_not be_nil
+				
+				tr.commit
+				@r['parent'].child.should be_nil
+				@r['parent'].children.should be_empty
+				@r['child1'].parent.should be_nil
+				@r['child2'].parent.should be_nil
+				@r.should include('child1')
+				@r.should include('child2')
+				@r.should_not include('parent/child1')
+				@r.should_not include('parent/child2')
+			end
+			
+			before :each do
+				ObjectModel::CONFIG[:directory] = "#{File.dirname __FILE__}/data"
+				
+				Repository.delete :test
+				@r = Repository.new :test
+				@r.transaction{CompositeEntity.new 'e'}.commit
+			end
+			
+			after :each do
+				@r.close
+				Repository.delete :test
+			end
+		end
+	end
+end

data/spec/complex_events_spec.rb

@@ -0,0 +1,134 @@
+require 'ObjectModel/require'
+require 'spec'
+
+module ObjectModel
+	module ComplexEventsSpec						
+		describe "Events" do				
+			class MockListener				
+				attr_reader :events, :arguments
+				def initialize
+					@events, @arguments = [], []
+				end
+				
+				def method_missing m, *p, &b
+					@events << m
+					@arguments << p
+				end
+				
+				def respond_to? symbol
+					true
+				end
+				
+				def clear
+					@events.clear
+				end
+			end								
+			
+			class BeforeRollbackEntity
+				inherit Entity
+				metadata do
+					before :new do
+						raise "abort"
+					end
+				end
+			end								
+			
+			class AfterRollbackEntity
+				inherit Entity
+				metadata do
+					after :new do
+						raise "abort"
+					end
+				end
+			end								
+			
+			it "Should Rollback Transaction if Exception is thrown during Before & After Event" do
+				lambda{
+					@r.transaction{BeforeRollbackEntity.new 'e'}.commit
+				}.should raise_error(/abort/)
+				@r.should_not include('e')
+				
+				lambda{
+					@r.transaction{AfterRollbackEntity.new 'e'}.commit
+				}.should raise_error(/abort/)
+				@r.should_not include('e')
+			end
+			
+			class AfterCommitEntity
+				inherit Entity
+				metadata do						
+					after :commit do
+						raise "abort"
+					end
+				end
+			end
+			
+			it "Shouldn't Rollback Transaction if Exception is thrown during after_commit" do
+				lambda{
+					@r.transaction{AfterCommitEntity.new 'e'}.commit
+				}.should raise_error(/abort/)
+				@r.should include('e')
+			end
+			
+			class User
+				inherit Entity
+				metadata do
+					child :folder
+					after :new do |e|
+						e.folder = UserFolder.new "#{e.name} folder"
+					end
+				end
+			end
+			
+			class UserFolder
+				inherit Entity			
+				metadata{}
+			end
+			
+			it "Changing another Entity during Event" do
+				@r.transaction{User.new 'u'}.commit
+				@r['u'].folder.name.should == "u folder"
+			end
+			
+			class BaseEntity
+				inherit Entity
+				metadata do
+					after :new do
+						BaseEntity.events << "base"
+					end
+				end
+				
+				def self.events 
+					@events ||= []
+				end
+			end
+			
+			class DescendantEntity < BaseEntity					
+				metadata do
+					after :new do
+						BaseEntity.events << "descendant"
+					end
+				end
+			end
+			
+			it "Events call sequence, first SuperClass Events should be called" do
+				@r.transaction{DescendantEntity.new 'de'}.commit
+				BaseEntity.events.should == ["base", "descendant"]
+			end
+			
+			before :each do
+				ObjectModel::CONFIG[:directory] = "#{File.dirname __FILE__}/data"
+				
+				Repository.delete :test									
+				@r = Repository.new :test
+				@l = MockListener.new
+				@r.entity_listeners << @l
+			end
+			
+			after :each do
+				@r.close
+				Repository.delete :test
+			end
+		end
+	end
+end

data/spec/concurrency_spec.rb

@@ -0,0 +1,186 @@
+require 'ObjectModel/require'
+require 'spec'
+require "#{File.dirname(__FILE__)}/timer"
+
+module ObjectModel
+	module ConcurrencySpec
+		describe "Concurrency" do	
+			class SimpleEntity
+				inherit Entity
+				metadata do
+					attribute :label, :string
+					attribute :value, :number
+				end
+			end			
+			
+			before :each do
+				ObjectModel::CONFIG[:directory] = "#{File.dirname __FILE__}/data"
+				
+				Repository.delete :test
+				@r = Repository.new :test
+			end
+			
+			after :each do
+				@r.close
+				Repository.delete :test
+			end
+			
+			it "Should raise Error if update is outdated" do		
+				@r.transaction{
+					SimpleEntity.new 'one'
+				}.commit
+				
+				t1 = Thread.new do
+					lambda{					
+						tr = @r.transaction{
+							@r['one'].label = "name one"
+						}
+						sleep 0.5
+						tr.commit							
+					}.should raise_error(OutdatedError)
+				end		
+								
+				t2 = Thread.new do				
+					@r.transaction{
+						@r['one'].label = "name two"
+					}.commit					
+				end
+				t1.join; t2.join
+				@r['one'].label.should == "name two"			
+			end
+			
+			it "General concurrency test" do
+				@r.transaction{
+					from = SimpleEntity.new 'from'
+					from.value = 5
+					to = SimpleEntity.new 'to'
+					to.value = 0
+				}.commit
+				
+				threads = []
+				20.times do
+					threads << Thread.new do
+						catch :done do
+							while true do					
+								@r.isolate do																												
+									throw :done if @r['from'].value <= 0							
+									
+									sleep(rand(10) / 1000.0)								
+									
+									begin
+										@r.transaction{
+											@r['from'].value -= 1
+											@r['to'].value += 1																
+										}.commit
+									rescue OutdatedError
+										next
+									end	
+								end
+							end					
+						end
+					end
+				end
+				threads.each{|t| t.join}
+				
+				@r['from'].value.should == 0
+				@r['to'].value.should == 5
+			end		
+			
+#			# There are 2 read_streamers and 2 put_streamrs, read_streamers should works in parallel, put_streamrs exclusivelly
+#			#                            
+#			#         4x5-----8         put_streamr 2
+#			#     2x3---5               put_streamr 1
+#			# 0-1                       read_streamer 2
+#			# 0-----3       7x8-9       read_streamer 1  
+#			# 0 1 2 3 4 5 6 7 8 9       timeline
+#			# 
+#			it "'read' operations should works in parallel and 'write' exclusivelly" do
+#				copy = @r.copy
+#				copy[:first] = SimpleEntity.new :first
+#				copy[:second] = SimpleEntity.new :second
+#				@r.commit
+#				
+#				timer = Timer.new
+#				r1 = mock("read 1")
+#				r1.should_receive(:created).with(0)
+#				r1.should_receive(:start).with(0)
+#				r1.should_receive(:finish).with(3)						
+#				Thread.new do
+#					r1.created timer.time
+#					@r.isolate do
+#						r1.start timer.time
+#						@r[:first]
+#						sleep 3
+#						@r[:second]
+#						r1.finish timer.time
+#					end
+#				end
+#				
+#				r2 = mock("read 2")
+#				r2.should_receive(:created).with(0)
+#				r2.should_receive(:start).with(0)
+#				r2.should_receive(:finish).with(1)						
+#				Thread.new do			
+#					r2.created timer.time
+#					@r.isolate do
+#						r2.start timer.time
+#						@r[:first]
+#						sleep 1
+#						@r[:second]
+#						r2.finish timer.time
+#					end
+#				end
+#				
+#				sleep 2
+#				
+#				w1 = mock("write 1")
+#				w1.should_receive(:created).with(2)
+#				w1.should_receive(:start).with(3)
+#				w1.should_receive(:finish).with(5)						
+#				Thread.new do							
+#					w1.created timer.time									
+#					@r.isolate do									
+#						copy = @r[:first].copy
+#						copy.value = 'new value'
+#						@r.om_engine.engine_commit_debug(2){w1.start timer.time}	# Should sleep for 2 sec
+#						w1.finish timer.time
+#					end
+#				end
+#				
+#				sleep 2
+#				
+#				w2 = mock("write 2")
+#				w2.should_receive(:created).with(4)
+#				w2.should_receive(:start).with(5)
+#				w2.should_receive(:finish).with(8)						
+#				Thread.new do
+#					w2.created timer.time
+#					@r.isolate do					
+#						copy = @r[:first].copy
+#						copy.value = "new value 2"
+#						@r.om_engine.engine_commit_debug(3){w2.start timer.time;} # Should sleep for 2 sec
+#						w2.finish timer.time
+#					end
+#				end
+#				
+#				sleep 3
+#				
+#				r11 = mock("put_streamr 2")
+#				r11.should_receive(:created).with(7)
+#				r11.should_receive(:start).with(8)
+#				r11.should_receive(:finish).with(9)						
+#				t = Thread.new do
+#					r11.created timer.time
+#					@r.isolate do
+#						r11.start timer.time
+#						@r[:first]
+#						sleep 1
+#						@r[:second]
+#						r11.finish timer.time
+#					end
+#				end	
+#				t.join
+#			end			
+		end
+	end
+end