rod 0.7.1 → 0.7.2

data/features/flat_indexing.feature

@@ -44,6 +44,12 @@ Feature: Access to objects with indexed fields
     And there should be 1 Caveman with '111222555' identifier
     And there should be 2 Caveman(s) with '1.67' height
     And there should be 1 Caveman with '1.86' height
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Fred' name should be equal to the first Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
   Scenario: indexing of fields with different DBs for the same model
     The contents of indices should be fulshed when the database is reopened.
@@ -62,7 +68,7 @@ Feature: Access to objects with indexed fields
     And I store him in the database
     And I reopen database for reading
     And I access the Caveman name index
-    And database is created in location2
+    And database is created in tmp/location2
     And I create a Caveman
     And his name is 'Wilma'
     And I store him in the database
@@ -72,10 +78,11 @@ Feature: Access to objects with indexed fields
     And I create another Caveman
     And his name is 'Wilma'
     And I store him in the database
-    And I reopen database for reading in location2
+    And I reopen database for reading in tmp/location2
     Then there should be 3 Caveman(s)
     And there should be 3 Caveman(s) with 'Wilma' name
     And there should be 0 Caveman(s) with 'Fred' name
+    And some Caveman with 'Wilma' name should be equal to the first Caveman
 
   Scenario: indexing of particular values
     Given the class space is cleared
@@ -139,3 +146,38 @@ Feature: Access to objects with indexed fields
     And I store him in the database
     Then there should exist a User with 'John' name
     And there should be 1 User with 'John' name
+
+  Scenario: iterating over the index key-values pairs
+      It should be possible to iterate over the keys of a index.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with flat index
+    When database is created
+    And I create a User
+    And his name is 'John'
+    And I store him in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Pipi'
+    And I store her in the database
+    And I reopen the database for reading
+    And I iterate over the name index of User
+    Then there should be 1 User with 'John' name in the iteration results
+    And there should be 2 User(s) with 'Lara' name in the iteration results
+    And there should be 1 User with 'Pipi' name in the iteration results
+    And there should be 0 User(s) with 'Fred' name in the iteration results
+
+  Scenario: indexing with empty database
+      Rod should behave well when there is an index on a model while
+      the database is created and nothing is stored in it.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with flat index
+    When database is created
+    And I reopen the database for reading
+    Then there should be 0 User(s)

data/features/hash_indexing.feature

@@ -18,19 +18,19 @@ Feature: Access to objects with hash indices.
     And I create a Caveman
     And his name is 'Fred'
     And his age is '25'
-    And his identifier is '111122223333'
+    And his identifier is '111222333'
     And his height is '1.86'
     And I store him in the database
     And I create another Caveman
     And his name is 'Barney'
     And his age is '26'
-    And his identifier is '111122224444'
+    And his identifier is '111222444'
     And his height is '1.67'
     And I store him in the database
     And I create another Caveman
     And his name is 'Wilma'
     And his age is '25'
-    And his identifier is '111122225555'
+    And his identifier is '111222555'
     And his height is '1.67'
     And I store her in the database
     And I reopen database for reading
@@ -40,11 +40,17 @@ Feature: Access to objects with hash indices.
     And there should be 1 Caveman with 'Barney' name
     And there should be 2 Caveman(s) with '25' age
     And there should be 1 Caveman with '26' age
-    And there should be 1 Caveman with '111122223333' identifier
-    And there should be 1 Caveman with '111122224444' identifier
-    And there should be 1 Caveman with '111122225555' identifier
+    And there should be 1 Caveman with '111222333' identifier
+    And there should be 1 Caveman with '111222444' identifier
+    And there should be 1 Caveman with '111222555' identifier
     And there should be 2 Caveman(s) with '1.67' height
     And there should be 1 Caveman with '1.86' height
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Fred' name should be equal to the first Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
     # Test re-creation of the database
     When database is created
@@ -62,6 +68,12 @@ Feature: Access to objects with hash indices.
     And there should be 1 Caveman with 'Fred' name
     And there should be 1 Caveman with 'Wilma' name
     And there should be 1 Caveman with 'Barney' name
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Fred' name should be equal to the first Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
   Scenario: extending the DB when hash index is used
       Rod should allow to extend the DB when the hash index is used.
@@ -88,6 +100,11 @@ Feature: Access to objects with hash indices.
     And there should be 1 Caveman with 'Wilma' name
     And there should be 2 Caveman(s) with 'Fred' name
     And there should be 1 Caveman with 'Barney' name
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
   Scenario: indexing of fields with different DBs for the same model with hash index
     The contents of indices should be fulshed when the database is reopened.
@@ -106,7 +123,7 @@ Feature: Access to objects with hash indices.
     And I store him in the database
     And I reopen database for reading
     And I access the Caveman name index
-    And database is created in location2
+    And database is created in tmp/location2
     And I create a Caveman
     And his name is 'Wilma'
     And I store him in the database
@@ -116,10 +133,11 @@ Feature: Access to objects with hash indices.
     And I create another Caveman
     And his name is 'Wilma'
     And I store him in the database
-    And I reopen database for reading in location2
+    And I reopen database for reading in tmp/location2
     Then there should be 3 Caveman(s)
     And there should be 3 Caveman(s) with 'Wilma' name
     And there should be 0 Caveman(s) with 'Fred' name
+    And some Caveman with 'Wilma' name should be equal to the first Caveman
 
   Scenario: indexing of particular values with hash index
     Given the class space is cleared
@@ -146,7 +164,7 @@ Feature: Access to objects with hash indices.
     And there should be 2 Caveman(s) with '' name
     And there should be 2 Caveman(s) with '' surname
 
-  Scenario: multiple object with indexed fields with hash index
+  Scenario: multiple objects with indexed fields with hash index
       The database should properly store thausands of objects with some indexed fields.
     Given the class space is cleared
     And the model is connected with the default database
@@ -170,3 +188,39 @@ Feature: Access to objects with hash indices.
     Then there should be 1000 User(s) with 'Smith' surname
     Then there should be 1000 User(s) with 'Lara' name
     Then there should be 1000 User(s) with 'Croft' surname
+    And some User with 'John' name should be equal to the first User
+
+  Scenario: iterating over the index key-values pairs
+      It should be possible to iterate over the keys of a index.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with hash index
+    When database is created
+    And I create a User
+    And his name is 'John'
+    And I store him in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Pipi'
+    And I store her in the database
+    And I reopen the database for reading
+    And I iterate over the name index of User
+    Then there should be 1 User with 'John' name in the iteration results
+    And there should be 2 User(s) with 'Lara' name in the iteration results
+    And there should be 1 User with 'Pipi' name in the iteration results
+    And there should be 0 User(s) with 'Fred' name in the iteration results
+
+  Scenario: indexing with empty database
+      Rod should behave well when there is an index on a model while
+      the database is created and nothing is stored in it.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with hash index
+    When database is created
+    And I reopen the database for reading
+    Then there should be 0 User(s)

data/features/portability.feature

@@ -0,0 +1,72 @@
+Feature: Data portability
+    The database should be portable across systems with different
+    byte order and processor register length.
+  Background:
+    Given the library works in development mode
+
+  Scenario: this scenario is used to generate the data used in portability tests
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    And a class Caveman has an age field of type integer
+    And a class Caveman has an identifier field of type ulong
+    And a class Caveman has a height field of type float
+    And a class Caveman has a account_balance field of type float
+    And a class Automobile has a name field of type string
+    And a class Caveman has one automobile
+    And a class Dog has a nickname field of type string
+    And a class Caveman has many dogs
+    When database is created
+    And I create an Automobile
+    And its name is 'Prehistoric car'
+    And I store it in the database
+    And I create a Dog
+    And its nickname is 'Snoopy'
+    And I store it in the database
+    And I create a Caveman
+    And his name is 'Fred'
+    And his age is '25'
+    And his identifier is '111222333'
+    And his height is '1.86'
+    And his account_balance is '-0.00000001'
+    And his automobile is the first Automobile created
+    And his dogs contain the first Dog created
+    And I store him in the database
+    And I reopen database for reading
+    Then there should be 1 Caveman
+    And there should be 1 Dog
+    And there should be 1 Automobile
+    And the name of the first Caveman should be 'Fred'
+    And the age of the first Caveman should be '25'
+    And the identifier of the first Caveman should be '111222333'
+    And the height of the first Caveman should be '1.86'
+    And the account_balance of the first Caveman should be '-0.00000001'
+    And the automobile of the first Caveman should be equal to the first Automobile
+    And the first of dogs of the first Caveman should be equal to the first Dog
+
+  # This feature will be turned on when #221 is implemented.
+  @ignore
+  Scenario: simple check of data portability
+      Rod should allow to read data created on a little endian 64-bit system
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class Caveman has a name field of type string
+    And a class Caveman has an age field of type integer
+    And a class Caveman has an identifier field of type ulong
+    And a class Caveman has a height field of type float
+    And a class Caveman has a account_balance field of type float
+    And a class Automobile has a name field of type string
+    And a class Caveman has one automobile
+    And a class Dog has a nickname field of type string
+    And a class Caveman has many dogs
+    When I open the database for reading in data/portability
+    Then there should be 1 Caveman
+    And there should be 1 Dog
+    And there should be 1 Automobile
+    And the name of the first Caveman should be 'Fred'
+    And the age of the first Caveman should be '25'
+    And the identifier of the first Caveman should be '111222333'
+    And the height of the first Caveman should be '1.86'
+    And the account_balance of the first Caveman should be '-0.00000001'
+    And the automobile of the first Caveman should be equal to the first Automobile persisted
+    And the first of dogs of the first Caveman should be equal to the first Dog persisted

data/features/segmented_indexing.feature

@@ -45,6 +45,12 @@ Feature: Access to objects with segmented indices.
     And there should be 1 Caveman with '111222555' identifier
     And there should be 2 Caveman(s) with '1.67' height
     And there should be 1 Caveman with '1.86' height
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Fred' name should be equal to the first Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
     # Test re-creation of the database
     When database is created
@@ -62,6 +68,12 @@ Feature: Access to objects with segmented indices.
     And there should be 1 Caveman with 'Fred' name
     And there should be 1 Caveman with 'Wilma' name
     And there should be 1 Caveman with 'Barney' name
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Fred' name should be equal to the first Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
   Scenario: extending the DB when segmented index is used
       Rod should allow to extend the DB when the segmented index is used.
@@ -88,6 +100,11 @@ Feature: Access to objects with segmented indices.
     And there should be 1 Caveman with 'Wilma' name
     And there should be 2 Caveman(s) with 'Fred' name
     And there should be 1 Caveman with 'Barney' name
+    And some Caveman with 'Fred' name should be equal to the first Caveman
+    And some Caveman with 'Barney' name should be equal to the second Caveman
+    And some Caveman with 'Wilma' name should be equal to the third Caveman
+    And the first Caveman with 'Barney' name should be equal to the second Caveman
+    And the first Caveman with 'Wilma' name should be equal to the third Caveman
 
   Scenario: indexing of fields with different DBs for the same model with segmented index
     The contents of indices should be fulshed when the database is reopened.
@@ -106,7 +123,7 @@ Feature: Access to objects with segmented indices.
     And I store him in the database
     And I reopen database for reading
     And I access the Caveman name index
-    And database is created in location2
+    And database is created in tmp/location2
     And I create a Caveman
     And his name is 'Wilma'
     And I store him in the database
@@ -116,10 +133,11 @@ Feature: Access to objects with segmented indices.
     And I create another Caveman
     And his name is 'Wilma'
     And I store him in the database
-    And I reopen database for reading in location2
+    And I reopen database for reading in tmp/location2
     Then there should be 3 Caveman(s)
     And there should be 3 Caveman(s) with 'Wilma' name
     And there should be 0 Caveman(s) with 'Fred' name
+    And some Caveman with 'Wilma' name should be equal to the first Caveman
 
   Scenario: indexing of particular values with segmented index
     Given the class space is cleared
@@ -170,3 +188,28 @@ Feature: Access to objects with segmented indices.
     Then there should be 1000 User(s) with 'Smith' surname
     Then there should be 1000 User(s) with 'Lara' name
     Then there should be 1000 User(s) with 'Croft' surname
+
+  Scenario: iterating over the index key-values pairs
+      It should be possible to iterate over the keys of a index.
+    Given the class space is cleared
+    And the model is connected with the default database
+    And a class User has a name field of type string with segmented index
+    When database is created
+    And I create a User
+    And his name is 'John'
+    And I store him in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Lara'
+    And I store her in the database
+    And I create a User
+    And her name is 'Pipi'
+    And I store her in the database
+    And I reopen the database for reading
+    And I iterate over the name index of User
+    Then there should be 1 User with 'John' name in the iteration results
+    And there should be 2 User(s) with 'Lara' name in the iteration results
+    And there should be 1 User with 'Pipi' name in the iteration results
+    And there should be 0 User(s) with 'Fred' name in the iteration results

data/features/steps/collection_proxy.rb

@@ -23,7 +23,7 @@ Given /^the initial size of the collection proxy is (\d+)$/ do |size|
   @array.each.with_index do |element,index|
     db.expects(:join_index).with(0,index).returns(element).at_least(0)
   end
-	@proxy = Rod::CollectionProxy.new(@array.size,db,@offset,Rod::Model)
+  @proxy = Rod::CollectionProxy.new(@array.size,db,@offset,Rod::Model)
   @offset += size
 end
 

data/features/steps/model.rb

@@ -67,6 +67,10 @@ def get_position(position)
     3
   when "fifth"
     4
+  when "sixth"
+    5
+  when "seventh"
+    6
   when "last"
     -1
   when Fixnum
@@ -234,6 +238,18 @@ When /^I remove the (\w+) of (?:his|her|its) (\w+)$/ do |position,property|
   @instance.send(property).delete_at(get_position(position))
 end
 
+# When I iterate over the name index of User
+When /^I iterate over the (\w+) index of (\w+)$/ do |field,class_name|
+  klass = get_class(class_name)
+  index = klass.property(field.to_sym).index
+  @results = []
+  index.each do |key,values|
+    values.each do |value|
+      @results << [key,value]
+    end
+  end
+end
+
 ################################################################
 # Then
 ################################################################
@@ -272,12 +288,13 @@ Then /^the (\w+) (\w+) should not have (a|an )?(\w+)$/ do |position, class_name,
 end
 
 Then /^the (\w+) (\w+) should not exist$/ do |position,class_name|
-  (lambda {get_instance(class_name,position)}).should raise_error(IndexError)
+  get_instance(class_name,position).should == nil
 end
 
-Then /^the (\w+) of the (\w+) (\w+) should be equal to the (\w+) (\w+)$/ do |field, position1,class1,position2,class2|
+Then /^the (\w+) of the (\w+) (\w+) should be equal to the (\w+) (\w+)( persisted)?$/ do |field, position1,class1,position2,class2,persisted|
+  created = !persisted
   get_instance(class1,position1).send(field.to_sym).should ==
-    get_instance(class2,position2,true)
+    get_instance(class2,position2,created)
 end
 
 Then /^the (\w+) of the (\w+) (\w+) should be nil$/ do |field,position1,class1|
@@ -313,9 +330,10 @@ Then /^(\w+)(\([^)]*\))? from (\d+) to (\d+) should have (\w+) of (\w+) equal to
   end
 end
 
-Then /^the (\w+) of (\w+) of the (\w+) (\w+) should be equal to the (\w+) (\w+)$/ do |position0,field,position1,class1,position2,class2|
+Then /^the (\w+) of (\w+) of the (\w+) (\w+) should be equal to the (\w+) (\w+)( persisted)?$/ do |position0,field,position1,class1,position2,class2,persisted|
+  created = !persisted
   get_instance(class1,position1).send(field.to_sym)[get_position(position0)].should ==
-    get_instance(class2,position2,true)
+    get_instance(class2,position2,created)
 end
 
 Then /^the (\w+) of (\w+) of the (\w+) (\w+) should be nil$/ do |position0,field,position1,class1|
@@ -396,3 +414,28 @@ end
 Then /^([\w:]+) should be raised$/ do |exception|
   @error.class.to_s.should == exception
 end
+
+# Then some User with 'Fred' name should be equal to the first User
+Then /^some (\w+) with '([^']*)' (\w+) should be equal to the (\w+) (\w+)$/ do |class1,value,field,position2,class2|
+  objects = get_class(class1).send("find_all_by_#{field}",get_value(value))
+  expected = get_instance(class2,position2)
+  objects.any?{|o| o == expected }.should == true
+end
+
+# Then the first User with 'Fred' name should be equal to the first User
+Then /^the first (\w+) with '([^']*)' (\w+) should be equal to the (\w+) (\w+)$/ do |class1,value,field,position2,class2|
+  get_class(class1).send("find_by_#{field}",get_value(value)).should ==
+    get_instance(class2,position2)
+end
+
+# Then there should be 1 User with 'John' name in the iteration results
+Then /^there should be (\d) (\w+)(?:\([^)]*\))? with '([^']*)' (\w+) in the iteration results$/ do |count,class_name,value,field|
+  @results.select{|k,v| k == value && v.send(field.to_sym) == value}.size.should == count.to_i
+end
+
+#Then the intersection size of automobiles of the first and the second Caveman should equal 2
+Then /^the intersection size of (\w+) of the (\w+) and the (\w+) (\w+) should equal (\d+)$/ do |field,position1,position2,klass,count|
+  elements1 = get_instance(klass,position1).send(field.to_sym)
+  elements2 = get_instance(klass,position2).send(field.to_sym)
+  elements1.intersection_size(elements2).should == count.to_i
+end