redis_orm 0.6.1 → 0.6.2

data/test/classes/uuid_default_user.rb

@@ -0,0 +1,12 @@
+class UuidDefaultUser < RedisOrm::Base
+  use_uuid_as_id
+  
+  property :name, String, :default => "german"
+  property :age, Integer, :default => 26
+  property :wage, Float, :default => 256.25
+  property :male, RedisOrm::Boolean, :default => true
+  property :admin, RedisOrm::Boolean, :default => false
+  
+  property :created_at, Time
+  property :modified_at, Time
+end

data/test/classes/uuid_timestamp.rb

@@ -0,0 +1,5 @@
+class UuidTimeStamp < RedisOrm::Base
+  use_uuid_as_id
+
+  timestamps
+end

data/test/classes/uuid_user.rb

@@ -0,0 +1,13 @@
+class UuidUser < RedisOrm::Base
+  use_uuid_as_id
+  
+  property :name, String
+  property :age, Integer
+  property :wage, Float
+  property :male, RedisOrm::Boolean
+
+  property :created_at, Time
+  property :modified_at, Time
+  
+  has_many :users, :as => :friends
+end

data/test/dynamic_finders_test.rb

@@ -1,46 +1,28 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class User < RedisOrm::Base
-  property :first_name, String
-  property :last_name, String
-
-  index :first_name, :unique => true
-  index :last_name,  :unique => true
-  index [:first_name, :last_name], :unique => false
-end
-
-class CustomUser < RedisOrm::Base
-  property :first_name, String
-  property :last_name, String
-
-  index :first_name, :unique => false
-  index :last_name,  :unique => false
-  index [:first_name, :last_name], :unique => true
-end
-
 describe "check associations" do
   it "should create and use indexes to implement dynamic finders" do
-    user1 = User.new
+    user1 = DynamicFinderUser.new
     user1.first_name = "Dmitrii"
     user1.last_name = "Samoilov"
     user1.save
 
-    User.find_by_first_name("John").should == nil
+    DynamicFinderUser.find_by_first_name("John").should == nil
 
-    user = User.find_by_first_name "Dmitrii"
+    user = DynamicFinderUser.find_by_first_name "Dmitrii"
     user.id.should == user1.id
 
-    User.find_all_by_first_name("Dmitrii").size.should == 1
+    DynamicFinderUser.find_all_by_first_name("Dmitrii").size.should == 1
 
-    user = User.find_by_first_name_and_last_name('Dmitrii', 'Samoilov')
+    user = DynamicFinderUser.find_by_first_name_and_last_name('Dmitrii', 'Samoilov')
     user.should be
     user.id.should == user1.id
 
-    User.find_all_by_first_name_and_last_name('Dmitrii', 'Samoilov').size.should == 1
+    DynamicFinderUser.find_all_by_first_name_and_last_name('Dmitrii', 'Samoilov').size.should == 1
 
-    User.find_all_by_last_name_and_first_name('Samoilov', 'Dmitrii')[0].id.should == user1.id
+    DynamicFinderUser.find_all_by_last_name_and_first_name('Samoilov', 'Dmitrii')[0].id.should == user1.id
 
-    lambda{User.find_by_first_name_and_cast_name('Dmitrii', 'Samoilov')}.should raise_error
+    lambda{DynamicFinderUser.find_by_first_name_and_cast_name('Dmitrii', 'Samoilov')}.should raise_error
   end
 
   it "should create and use indexes to implement dynamic finders" do
@@ -62,6 +44,7 @@ describe "check associations" do
     CustomUser.find_all_by_first_name("Dmitrii").size.should == 2
   end
 
+  # TODO
   it "should properly delete indices when record was deleted" do
     
   end

data/test/exceptions_test.rb

@@ -1,25 +1,5 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class User < RedisOrm::Base
-  property :name, String
-  property :age, Integer
-  property :created_at, Time
-
-  index :age
-  
-  has_one :profile
-end
-
-class Profile < RedisOrm::Base
-  property :title, String
-  belongs_to :user
-end
-
-class Jigsaw < RedisOrm::Base
-  property :title, String
-  belongs_to :user
-end
-
 describe "exceptions test" do
   it "should raise an exception if association is provided with improper class" do
     User.count.should == 0
@@ -31,7 +11,7 @@ describe "exceptions test" do
     user.name.should == "german"
     User.count.should == 1
 
-    lambda{ User.find :all, :conditions => {:name => "german"} }.should raise_error
+    lambda{ User.find :all, :conditions => {:gender => true} }.should raise_error
     User.find(:all, :conditions => {:age => 26}).size.should == 1
     lambda{ User.find :all, :conditions => {:name => "german", :age => 26} }.should raise_error
     

data/test/has_one_has_many_test.rb

@@ -1,17 +1,5 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class Profile < RedisOrm::Base
-  property :name, String
-
-  has_one :location
-end
-
-class Location < RedisOrm::Base
-  property :coordinates, String
-  
-  has_many :profiles
-end
-
 describe "check associations" do
   it "should save associations properly" do
     @profile = Profile.new

data/test/indices_test.rb

@@ -1,23 +1,5 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class User < RedisOrm::Base
-  property :first_name, String
-  property :last_name, String
-
-  index :first_name
-  index :last_name
-  index [:first_name, :last_name]
-end
-
-class OmniUser < RedisOrm::Base
-  property :email, String
-  property :uid, Integer
-
-  index :email, :case_insensitive => true
-  index :uid
-  index [:email, :uid], :case_insensitive => true
-end
-
 describe "check indices" do
   it "should change index accordingly to the changes in the model" do
     user = User.new :first_name => "Robert", :last_name => "Pirsig"

data/test/modules/belongs_to_model_within_module.rb

@@ -0,0 +1,6 @@
+module BelongsToModelWithinModule
+  class Reply < RedisOrm::Base
+    property :body, String, :default => "test"
+    belongs_to :article, :as => :essay
+  end
+end

data/test/modules/has_many_model_within_module.rb

@@ -0,0 +1,11 @@
+module HasManyModelWithinModule
+  class SpecialComment < RedisOrm::Base
+    property :body, String, :default => "test"
+    belongs_to :brochure, :as => :book
+  end
+
+  class Brochure < RedisOrm::Base
+    property :title, String
+    has_many :special_comments
+  end
+end

data/test/options_test.rb

@@ -1,42 +1,5 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class Album < RedisOrm::Base
-  property :title, String
-
-  has_one :photo, :as => :front_photo
-  has_many :photos, :dependent => :destroy
-end
-
-class Category < RedisOrm::Base
-  property :title, String
-
-  has_many :photos, :dependent => :nullify
-end
-
-class Photo < RedisOrm::Base
-  property :image, String
-  property :image_type, String
-  
-  property :checked, RedisOrm::Boolean, :default => false
-  index :checked
-  
-  property :inverted, RedisOrm::Boolean, :default => true
-  index :inverted
-  
-  index :image
-  index [:image, :image_type]
-  
-  belongs_to :album
-  belongs_to :user
-  belongs_to :category
-end
-
-class User < RedisOrm::Base
-  property :name, String
-  
-  has_one :photo, :dependent => :destroy
-end
-
 describe "test options" do
   before(:each) do
     @album = Album.new

data/test/polymorphic_test.rb

@@ -1,44 +1,5 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class CatalogItem < RedisOrm::Base
-  property :title, String
-
-  belongs_to :resource, :polymorphic => true
-end
-
-class Book < RedisOrm::Base
-  property :price, Integer, :default => 0 # in cents
-  property :title, String
-  
-  has_one :catalog_item
-end
-
-class Giftcard < RedisOrm::Base
-  property :price, Integer, :default => 0 # in cents
-  property :title, String
-
-  has_one :catalog_item
-end
-
-# for second test
-class Person < RedisOrm::Base
-  property :name, String
-  
-  belongs_to :location, :polymorphic => true
-end
-
-class Country < RedisOrm::Base
-  property :name, String
-
-  has_many :people
-end
-
-class City < RedisOrm::Base
-  property :name, String
-
-  has_many :people
-end
-
 describe "check polymorphic property" do
   it "should provide proper associations and save records correctly for has_one/belongs_to polymorphic" do
     book = Book.new :title => "Permutation City", :author => "Egan Greg", :price => 1529

data/test/sortable_test.rb

@@ -1,130 +1,116 @@
 require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
 
-class User < RedisOrm::Base
-  property :name, String, :sortable => true
-  property :age, Integer, :sortable => true
-  property :wage, Float, :sortable => true
-  
-  property :address, String
-  
-  index :name
-  index :age
-end
-
-class SortableUser < RedisOrm::Base
-  property :name, String, :sortable => true
-  index :name
-end
-
 describe "test options" do
   before(:each) do
-    @dan     = User.create :name => "Daniel",   :age => 26, :wage => 40000.0,   :address => "Bellevue"
-    @abe     = User.create :name => "Abe",      :age => 30, :wage => 100000.0,  :address => "Bellevue"
-    @michael = User.create :name => "Michael",  :age => 25, :wage => 60000.0,   :address => "Bellevue"
-    @todd    = User.create :name => "Todd",     :age => 22, :wage => 30000.0,   :address => "Bellevue"
+    @dan     = SortableUser.create :name => "Daniel",   :age => 26, :wage => 40000.0,   :address => "Bellevue"
+    @abe     = SortableUser.create :name => "Abe",      :age => 30, :wage => 100000.0,  :address => "Bellevue"
+    @michael = SortableUser.create :name => "Michael",  :age => 25, :wage => 60000.0,   :address => "Bellevue"
+    @todd    = SortableUser.create :name => "Todd",     :age => 22, :wage => 30000.0,   :address => "Bellevue"
   end
 
   it "should return records in specified order" do
-    $redis.llen("user:name_ids").to_i.should == User.count
-    $redis.zcard("user:age_ids").to_i.should == User.count
-    $redis.zcard("user:wage_ids").to_i.should == User.count
+    $redis.llen("sortable_user:name_ids").to_i.should == SortableUser.count
+    $redis.zcard("sortable_user:age_ids").to_i.should == SortableUser.count
+    $redis.zcard("sortable_user:wage_ids").to_i.should == SortableUser.count
     
-    User.find(:all, :order => [:name, :asc]).should == [@abe, @dan, @michael, @todd]
-    User.find(:all, :order => [:name, :desc]).should == [@todd, @michael, @dan, @abe]
+    SortableUser.find(:all, :order => [:name, :asc]).should == [@abe, @dan, @michael, @todd]
+    SortableUser.find(:all, :order => [:name, :desc]).should == [@todd, @michael, @dan, @abe]
     
-    User.find(:all, :order => [:age, :asc]).should == [@todd, @michael, @dan, @abe]
-    User.find(:all, :order => [:age, :desc]).should == [@abe, @dan, @michael, @todd]
+    SortableUser.find(:all, :order => [:age, :asc]).should == [@todd, @michael, @dan, @abe]
+    SortableUser.find(:all, :order => [:age, :desc]).should == [@abe, @dan, @michael, @todd]
     
-    User.find(:all, :order => [:wage, :asc]).should == [@todd, @dan, @michael, @abe]
-    User.find(:all, :order => [:wage, :desc]).should == [@abe, @michael, @dan, @todd]
+    SortableUser.find(:all, :order => [:wage, :asc]).should == [@todd, @dan, @michael, @abe]
+    SortableUser.find(:all, :order => [:wage, :desc]).should == [@abe, @michael, @dan, @todd]
   end
 
   it "should return records which met specified conditions in specified order" do
-    @abe2    = User.create :name => "Abe",      :age => 12, :wage => 10.0,      :address => "Santa Fe"
+    @abe2    = SortableUser.create :name => "Abe",      :age => 12, :wage => 10.0,      :address => "Santa Fe"
     
     # :asc should be default value for property in :order clause
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage]).should == [@abe2, @abe]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:wage]).should == [@abe2, @abe]
     
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :desc]).should == [@abe, @abe2]
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :asc]).should == [@abe2, @abe]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :desc]).should == [@abe, @abe2]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :asc]).should == [@abe2, @abe]
     
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:age, :desc]).should == [@abe, @abe2]
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:age, :asc]).should == [@abe2, @abe]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:age, :desc]).should == [@abe, @abe2]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:age, :asc]).should == [@abe2, @abe]
     
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :desc]).should == [@abe, @abe2]
-    User.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :asc]).should == [@abe2, @abe]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :desc]).should == [@abe, @abe2]
+    SortableUser.find(:all, :conditions => {:name => "Abe"}, :order => [:wage, :asc]).should == [@abe2, @abe]
   end
 
   it "should update keys after the persisted object was edited and sort properly" do
     @abe.update_attributes :name => "Zed", :age => 12, :wage => 10.0, :address => "Santa Fe"
 
-    $redis.llen("user:name_ids").to_i.should == User.count
-    $redis.zcard("user:age_ids").to_i.should == User.count
-    $redis.zcard("user:wage_ids").to_i.should == User.count
+    $redis.llen("sortable_user:name_ids").to_i.should == SortableUser.count
+    $redis.zcard("sortable_user:age_ids").to_i.should == SortableUser.count
+    $redis.zcard("sortable_user:wage_ids").to_i.should == SortableUser.count
 
-    User.find(:all, :order => [:name, :asc]).should == [@dan, @michael, @todd, @abe]
-    User.find(:all, :order => [:name, :desc]).should == [@abe, @todd, @michael, @dan]
+    SortableUser.find(:all, :order => [:name, :asc]).should == [@dan, @michael, @todd, @abe]
+    SortableUser.find(:all, :order => [:name, :desc]).should == [@abe, @todd, @michael, @dan]
         
-    User.find(:all, :order => [:age, :asc]).should == [@abe, @todd, @michael, @dan]
-    User.find(:all, :order => [:age, :desc]).should == [@dan, @michael, @todd, @abe]
+    SortableUser.find(:all, :order => [:age, :asc]).should == [@abe, @todd, @michael, @dan]
+    SortableUser.find(:all, :order => [:age, :desc]).should == [@dan, @michael, @todd, @abe]
     
-    User.find(:all, :order => [:wage, :asc]).should == [@abe, @todd, @dan, @michael]
-    User.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd, @abe]
+    SortableUser.find(:all, :order => [:wage, :asc]).should == [@abe, @todd, @dan, @michael]
+    SortableUser.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd, @abe]
   end
 
   it "should update keys after the persisted object was deleted and sort properly" do
-    user_count = User.count
+    user_count = SortableUser.count
     @abe.destroy
 
-    $redis.llen("user:name_ids").to_i.should == user_count - 1
-    $redis.zcard("user:age_ids").to_i.should == user_count - 1
-    $redis.zcard("user:wage_ids").to_i.should == user_count - 1
+    $redis.llen("sortable_user:name_ids").to_i.should == user_count - 1
+    $redis.zcard("sortable_user:age_ids").to_i.should == user_count - 1
+    $redis.zcard("sortable_user:wage_ids").to_i.should == user_count - 1
 
-    User.find(:all, :order => [:name, :asc]).should == [@dan, @michael, @todd]
-    User.find(:all, :order => [:name, :desc]).should == [@todd, @michael, @dan]
+    SortableUser.find(:all, :order => [:name, :asc]).should == [@dan, @michael, @todd]
+    SortableUser.find(:all, :order => [:name, :desc]).should == [@todd, @michael, @dan]
         
-    User.find(:all, :order => [:age, :asc]).should == [@todd, @michael, @dan]
-    User.find(:all, :order => [:age, :desc]).should == [@dan, @michael, @todd]
+    SortableUser.find(:all, :order => [:age, :asc]).should == [@todd, @michael, @dan]
+    SortableUser.find(:all, :order => [:age, :desc]).should == [@dan, @michael, @todd]
     
-    User.find(:all, :order => [:wage, :asc]).should == [@todd, @dan, @michael]
-    User.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd]
+    SortableUser.find(:all, :order => [:wage, :asc]).should == [@todd, @dan, @michael]
+    SortableUser.find(:all, :order => [:wage, :desc]).should == [@michael, @dan, @todd]
   end
 
   it "should sort objects with more than 3-4 symbols" do
-    vladislav = User.create :name => "Vladislav", :age => 19, :wage => 120.0
-    vladimir = User.create :name => "Vladimir", :age => 22, :wage => 220.5
-    vlad = User.create :name => "Vlad", :age => 29, :wage => 1200.0
+    vladislav = SortableUser.create :name => "Vladislav", :age => 19, :wage => 120.0
+    vladimir = SortableUser.create :name => "Vladimir", :age => 22, :wage => 220.5
+    vlad = SortableUser.create :name => "Vlad", :age => 29, :wage => 1200.0
     
-    User.find(:all, :order => [:name, :desc], :limit => 3).should == [vladislav, vladimir, vlad]
-    User.find(:all, :order => [:name, :desc], :limit => 2, :offset => 4).should == [@michael, @dan]
-    User.find(:all, :order => [:name, :desc], :offset => 3).should == [@todd, @michael, @dan, @abe]
-    User.find(:all, :order => [:name, :desc]).should == [vladislav, vladimir, vlad, @todd, @michael, @dan, @abe]
-
-    User.find(:all, :order => [:name, :asc], :limit => 3, :offset => 4).should == [vlad, vladimir, vladislav]
-    User.find(:all, :order => [:name, :asc], :offset => 3).should == [@todd, vlad, vladimir, vladislav]
-    User.find(:all, :order => [:name, :asc], :limit => 3).should == [@abe, @dan, @michael]
-    User.find(:all, :order => [:name, :asc]).should == [@abe, @dan, @michael, @todd, vlad, vladimir, vladislav]
+    SortableUser.find(:all, :order => [:name, :desc], :limit => 3).should == [vladislav, vladimir, vlad]
+    SortableUser.find(:all, :order => [:name, :desc], :limit => 2, :offset => 4).should == [@michael, @dan]
+    SortableUser.find(:all, :order => [:name, :desc], :offset => 3).should == [@todd, @michael, @dan, @abe]
+    SortableUser.find(:all, :order => [:name, :desc]).should == [vladislav, vladimir, vlad, @todd, @michael, @dan, @abe]
+
+    SortableUser.find(:all, :order => [:name, :asc], :limit => 3, :offset => 4).should == [vlad, vladimir, vladislav]
+    SortableUser.find(:all, :order => [:name, :asc], :offset => 3).should == [@todd, vlad, vladimir, vladislav]
+    SortableUser.find(:all, :order => [:name, :asc], :limit => 3).should == [@abe, @dan, @michael]
+    SortableUser.find(:all, :order => [:name, :asc]).should == [@abe, @dan, @michael, @todd, vlad, vladimir, vladislav]
   end
 
   it "should properly handle multiple users with almost the same names" do
-    users = []
+    users = [@abe, @todd, @michael, @dan]
     20.times{|i| users << SortableUser.create(:name => "user#{i}") }
-    SortableUser.all(:order => [:name, :asc]).should == users.sort{|n,m| n.name <=> m.name}
+    users.sort{|n,m| n.name <=> m.name}.should == SortableUser.all(:order => [:name, :asc])
   end
 
   it "should properly handle multiple users with almost the same names (descending order)" do
-    rev_users = []
+    rev_users = [@abe, @todd, @michael, @dan]
     20.times{|i| rev_users << SortableUser.create(:name => "user#{i}") }
     SortableUser.all(:order => [:name, :desc]).should == rev_users.sort{|n,m| n.name <=> m.name}.reverse
   end
 
   it "should properly store records with the same names" do
-    users = []
+    users = [@abe, @todd, @michael, @dan]
     users << SortableUser.create(:name => "user#1")
     users << SortableUser.create(:name => "user#2")
     users << SortableUser.create(:name => "user#1")
     users << SortableUser.create(:name => "user#2")
-    SortableUser.all(:order => [:name, :desc]).should == users.sort{|n,m| n.name <=> m.name}.reverse
-    SortableUser.all(:order => [:name, :asc]).should == users.sort{|n,m| n.name <=> m.name}
+
+    # we pluck only *name* here since it didn't sort by id (and it could be messed up)
+    SortableUser.all(:order => [:name, :desc]).map{|u| u.name}.should == users.sort{|n,m| n.name <=> m.name}.map{|u| u.name}.reverse
+    SortableUser.all(:order => [:name, :asc]).map{|u| u.name}.should == users.sort{|n,m| n.name <=> m.name}.map{|u| u.name}
   end
 end