redis_orm 0.5.1 → 0.8

data/test/callbacks_test.rb

@@ -1,119 +0,0 @@
-require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
-
-class CutoutAggregator < RedisOrm::Base
-  property :modified_at, Time
-
-  property :revision, Integer, :default => 0
-end
-
-class Cutout < RedisOrm::Base
-  property :filename, String
-
-  before_create :increase_revisions
-  before_destroy :decrease_revisions
-
-  def increase_revisions
-    ca = CutoutAggregator.last
-    ca.update_attribute(:revision, ca.revision + 1) if ca
-  end
-
-  def decrease_revisions
-    ca = CutoutAggregator.first
-    if ca.revision > 0
-      ca.update_attribute :revision, ca.revision - 1
-    end
-
-    ca.destroy if ca.revision == 0
-  end
-end
-
-class Comment < RedisOrm::Base
-  property :text, String
-
-  belongs_to :user
-
-  before_save :trim_whitespaces
-  after_save :regenerate_karma
-
-  def trim_whitespaces
-    self.text = self.text.strip
-  end
-
-  def regenerate_karma
-    if self.user
-      self.user.update_attribute :karma, (self.user.karma - self.text.length)
-    end
-  end
-end
-
-class User < RedisOrm::Base
-  property :first_name, String
-  property :last_name, String
-
-  property :karma, Integer, :default => 1000
-
-  index :first_name
-  index :last_name
-  index [:first_name, :last_name]
-
-  has_many :comments
-
-  after_create :store_in_rating
-  after_destroy :after_destroy_callback
-
-  def store_in_rating
-    $redis.zadd "users:sorted_by_rating", 0.0, self.id
-  end
-
-  def after_destroy_callback
-    self.comments.map{|c| c.destroy}
-  end
-end
-
-describe "check callbacks" do
-  it "should fire after_create/after_destroy callbacks" do
-    user = User.new :first_name => "Robert", :last_name => "Pirsig"
-    user.save
-
-    $redis.zrank("users:sorted_by_rating", user.id).should == 0
-
-    comment = Comment.create :text => "First!"
-    user.comments << comment
-
-    u = User.first
-    u.id.should == user.id
-    u.comments.count.should == 1
-    u.destroy
-    u.comments.count.should == 0
-  end
-
-  it "should fire before_create/before_destroy callbacks" do
-    CutoutAggregator.create
-
-    CutoutAggregator.count.should == 1
-    Cutout.create :filename => "1.jpg"
-    Cutout.create :filename => "2.jpg"
-    CutoutAggregator.last.revision.should == 2
-    Cutout.last.destroy
-    Cutout.last.destroy
-    CutoutAggregator.count.should == 0
-  end
-
-  it "should fire after_save/before_save callbacks" do
-    comment = Comment.new :text => "      Trim meeee !   "
-    comment.save
-    Comment.first.text.should == "Trim meeee !"
-
-    user = User.new :first_name => "Robert", :last_name => "Pirsig"
-    user.save
-    user.karma.should == 1000
-
-    user.comments << comment
-    user.comments.count == 1
-
-    c = Comment.first
-    c.update_attributes :text => "Another brick in the wall"
-
-    User.first.karma.should == 975
-  end
-end

data/test/changes_array_test.rb

@@ -1,31 +0,0 @@
-require File.dirname(File.expand_path(__FILE__)) + '/test_helper.rb'
-
-class User < RedisOrm::Base
-  property :name, String
-  property :age, Integer, :default => 26
-  property :gender, RedisOrm::Boolean, :default => true
-end
-
-describe "check associations" do
-  it "should return correct _changes array" do
-    user = User.new :name => "german"
-    user.name_changed?.should == false
-    
-    user.name_changes.should == ["german"]
-    user.save
-    
-    user.name_changes.should == ["german"]
-    user.name = "germaninthetown"
-    user.name_changes.should == ["german", "germaninthetown"]
-    user.name_changed?.should == true
-    user.save
-
-    user = User.first
-    user.name.should == "germaninthetown"
-    user.name_changed?.should == false
-    user.name_changes.should == ["germaninthetown"]
-    user.name = "german"
-    user.name_changed?.should == true
-    user.name_changes.should == ["germaninthetown", "german"]
-  end
-end

data/test/dynamic_finders_test.rb

@@ -1,68 +0,0 @@
-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.first_name = "Dmitrii"
-    user1.last_name = "Samoilov"
-    user1.save
-
-    User.find_by_first_name("John").should == nil
-
-    user = User.find_by_first_name "Dmitrii"
-    user.id.should == user1.id
-
-    User.find_all_by_first_name("Dmitrii").size.should == 1
-
-    user = User.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
-
-    User.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
-  end
-
-  it "should create and use indexes to implement dynamic finders" do
-    user1 = CustomUser.new
-    user1.first_name = "Dmitrii"
-    user1.last_name = "Samoilov"
-    user1.save
-
-    user2 = CustomUser.new
-    user2.first_name = "Dmitrii"
-    user2.last_name = "Nabaldyan"
-    user2.save
-
-    user = CustomUser.find_by_first_name "Dmitrii"
-    user.id.should == user1.id
-
-    CustomUser.find_by_last_name("Krassovkin").should == nil
-
-    CustomUser.find_all_by_first_name("Dmitrii").size.should == 2
-  end
-
-  it "should properly delete indices when record was deleted" do
-    
-  end
-end

data/test/exceptions_test.rb

@@ -1,45 +0,0 @@
-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
-
-    user = User.new :name => "german", :age => 26
-    user.save
-
-    user.should be
-    user.name.should == "german"
-    User.count.should == 1
-
-    lambda{ User.find :all, :conditions => {:name => "german"} }.should raise_error
-    User.find(:all, :conditions => {:age => 26}).size.should == 1
-    lambda{ User.find :all, :conditions => {:name => "german", :age => 26} }.should raise_error
-    
-    jigsaw = Jigsaw.new
-    jigsaw.title = "123"
-    jigsaw.save
-
-    # RedisOrm::TypeMismatchError
-    lambda { user.profile = jigsaw }.should raise_error
-  end   
-end

data/test/has_one_has_many_test.rb

@@ -1,54 +0,0 @@
-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
-    @profile.name = "my profile"
-    @profile.save
-
-    @profile.should be
-    @profile.name.should == "my profile"
-
-    @location1 = Location.new
-    @location1.coordinates = "44.343456345 56.23341432"
-    @location1.save
-    @location1.should be
-    @location1.coordinates.should == "44.343456345 56.23341432"
-
-    @profile.location = @location1
-
-    @profile.location.should be
-    @profile.location.id.should == @location1.id
-
-    @location1.profiles.size.should == 1
-    @location1.profiles.first.id.should == @profile.id
-
-    # check second profile
-    @profile2 = Profile.new
-    @profile2.name = "someone else's profile"
-    @profile2.save
-
-    @profile2.should be
-    @profile2.name.should == "someone else's profile"
-
-    @profile2.location = @location1
-
-    @profile2.location.should be
-    @profile2.location.id.should == @location1.id
-
-    @location1.profiles.size.should == 2
-    @location1.profiles.collect{|p| p.id}.sort.should == [@profile.id, @profile2.id].sort
-  end
-end

data/test/indices_test.rb

@@ -1,81 +0,0 @@
-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"
-    user.save
-
-    u = User.find_by_first_name("Robert")
-    u.id.should == user.id
-
-    u = User.find_by_first_name_and_last_name("Robert", "Pirsig")
-    u.id.should == user.id
-
-    u.first_name = "Chris"
-    u.save
-
-    User.find_by_first_name("Robert").should == nil
-
-    User.find_by_first_name_and_last_name("Robert", "Pirsig").should == nil
-
-    User.find_by_first_name("Chris").id.should == user.id
-    User.find_by_last_name("Pirsig").id.should == user.id
-    User.find_by_first_name_and_last_name("Chris", "Pirsig").id.should == user.id    
-  end
-
-  it "should change index accordingly to the changes in the model (test #update_attributes method)" do
-    user = User.new :first_name => "Robert", :last_name => "Pirsig"
-    user.save
-
-    u = User.find_by_first_name("Robert")
-    u.id.should == user.id
-
-    u = User.find_by_first_name_and_last_name("Robert", "Pirsig")
-    u.id.should == user.id
-
-    u.update_attributes :first_name => "Christofer", :last_name => "Robin"
-
-    User.find_by_first_name("Robert").should == nil
-    User.find_by_last_name("Pirsig").should == nil
-    User.find_by_first_name_and_last_name("Robert", "Pirsig").should == nil
-
-    User.find_by_first_name("Christofer").id.should == user.id
-    User.find_by_last_name("Robin").id.should == user.id
-    User.find_by_first_name_and_last_name("Christofer", "Robin").id.should == user.id    
-  end
-  
-  it "should create case insensitive indices too" do
-    ou = OmniUser.new :email => "GERMAN@Ya.ru", :uid => 2718281828
-    ou.save
-    
-    OmniUser.count.should == 1
-    OmniUser.find_by_email("german@ya.ru").should be
-    OmniUser.find_all_by_email("german@ya.ru").count.should == 1
-    
-    OmniUser.find_by_email_and_uid("german@ya.ru", 2718281828).should be
-    OmniUser.find_all_by_email_and_uid("german@ya.ru", 2718281828).count.should == 1
-
-    OmniUser.find_by_email("geRman@yA.rU").should be
-    OmniUser.find_all_by_email_and_uid("GerMan@Ya.ru", 2718281828).count.should == 1
-        
-    OmniUser.find_all_by_email_and_uid("german@ya.ru", 2718281829).count.should == 0
-  end
-end

data/test/options_test.rb

@@ -1,243 +0,0 @@
-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
-    @album.title = "my 1st album"
-    @album.save
-
-    @album.should be
-    @album.title.should == "my 1st album"
-
-    @photo1 = Photo.new :image => "facepalm.jpg", :image_type => "jpg", :checked => true
-    @photo1.save
-    @photo1.should be
-    @photo1.image.should == "facepalm.jpg"
-    @photo1.image_type.should == "jpg"
-
-    @photo2 = Photo.new :image => "boobs.png", :image_type => "png", :inverted => false
-    @photo2.save
-    @photo2.should be
-    @photo2.image.should == "boobs.png"
-    @photo2.image_type.should == "png"
-  end
-
-  it "should return correct array when :limit and :offset options are provided" do
-    @album.photos.count.should == 0
-
-    @album.photos.all(:limit => 2, :offset => 0).should == []
-
-    @album.photos << [@photo1, @photo2]
-
-    @album.photos.all(:limit => 0, :offset => 0).should == []
-    @album.photos.all(:limit => 1, :offset => 0).size.should == 1
-    @album.photos.all(:limit => 2, :offset => 0).size.should == 2 #[@photo1, @photo2]
-
-    @album.photos.all(:limit => 0, :offset => 0).should == []
-    @album.photos.all(:limit => 1, :offset => 1).size.should == 1 # [@photo2]
-    @album.photos.all(:limit => 2, :offset => 2).should == []
-
-    @album.photos.find(:all, :limit => 1, :offset => 1).size.should == 1
-    
-    Photo.find(:all).size.should == 2
-    Photo.find(:first).id.should == @photo1.id
-    Photo.find(:last).id.should == @photo2.id
-    
-    Photo.find(:all, :conditions => {:image => "facepalm.jpg"}).size.should == 1
-    Photo.find(:all, :conditions => {:image => "boobs.png"}).size.should == 1
-
-    Photo.find(:all, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).size.should == 1
-    Photo.find(:all, :conditions => {:image => "boobs.png", :image_type => "png"}).size.should == 1
-        
-    Photo.find(:first, :conditions => {:image => "facepalm.jpg"}).id.should == @photo1.id
-    Photo.find(:first, :conditions => {:image => "boobs.png"}).id.should == @photo2.id
-    
-    Photo.find(:first, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).id.should == @photo1.id
-    Photo.find(:first, :conditions => {:image => "boobs.png", :image_type => "png"}).id.should == @photo2.id
-    
-    Photo.find(:last, :conditions => {:image => "facepalm.jpg"}).id.should == @photo1.id
-    Photo.find(:last, :conditions => {:image => "boobs.png"}).id.should == @photo2.id
-    
-    Photo.find(:last, :conditions => {:image => "facepalm.jpg", :image_type => "jpg"}).id.should == @photo1.id
-    Photo.find(:last, :conditions => {:image => "boobs.png", :image_type => "png"}).id.should == @photo2.id
-  end
-
-  it "should correctly save boolean values" do
-    $redis.hgetall("photo:#{@photo1.id}")["inverted"].should == "true"
-    $redis.hgetall("photo:#{@photo2.id}")["inverted"].should == "false"
-
-    @photo1.inverted.should == true 
-    @photo2.inverted.should == false
-        
-    $redis.zrange("photo:inverted:true", 0, -1).should include(@photo1.id.to_s)
-    $redis.zrange("photo:inverted:false", 0, -1).should include(@photo2.id.to_s)
-    
-    $redis.hgetall("photo:#{@photo1.id}")["checked"].should == "true"
-    $redis.hgetall("photo:#{@photo2.id}")["checked"].should == "false"
-    
-    @photo1.checked.should == true
-    @photo2.checked.should == false
-    
-    $redis.zrange("photo:checked:true", 0, -1).should include(@photo1.id.to_s)
-    $redis.zrange("photo:checked:false", 0, -1).should include(@photo2.id.to_s)
-  end
-
-  it "should search on bool values properly" do
-    Photo.find(:all, :conditions => {:checked => true}).size.should == 1
-    Photo.find(:all, :conditions => {:checked => true}).first.id.should == @photo1.id
-    Photo.find(:all, :conditions => {:checked => false}).size.should == 1
-    Photo.find(:all, :conditions => {:checked => false}).first.id.should == @photo2.id
-    
-    Photo.find(:all, :conditions => {:inverted => true}).size.should == 1
-    Photo.find(:all, :conditions => {:inverted => true}).first.id.should == @photo1.id
-    Photo.find(:all, :conditions => {:inverted => false}).size.should == 1
-    Photo.find(:all, :conditions => {:inverted => false}).first.id.should == @photo2.id
-  end
-
-  it "should return correct array when :order option is provided" do
-    Photo.all(:order => "asc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    Photo.all(:order => "desc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
-
-    Photo.all(:order => "asc", :limit => 1).map{|p| p.id}.should == [@photo1.id]
-    Photo.all(:order => "desc", :limit => 1).map{|p| p.id}.should == [@photo2.id]
-
-    Photo.all(:order => "asc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo2.id]
-    Photo.all(:order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
-
-    # testing #find method
-    Photo.find(:all, :order => "asc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    Photo.find(:all, :order => "desc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
-
-    Photo.find(:all, :order => "asc", :limit => 1).map{|p| p.id}.should == [@photo1.id]
-    Photo.find(:all, :order => "desc", :limit => 1).map{|p| p.id}.should == [@photo2.id]
-
-    Photo.find(:first, :order => "asc", :limit => 1, :offset => 1).id.should == @photo2.id
-    Photo.find(:first, :order => "desc", :limit => 1, :offset => 1).id.should == @photo1.id
-
-    Photo.find(:last, :order => "asc").id.should == @photo2.id
-    Photo.find(:last, :order => "desc").id.should == @photo1.id
-    
-    @album.photos.count.should == 0
-    @album.photos.all(:limit => 2, :offset => 0).should == []
-    @album.photos << @photo2
-    @album.photos << @photo1
-
-    @album.photos.all(:order => "asc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
-    @album.photos.all(:order => "desc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    @album.photos.all(:order => "asc", :limit => 1).map{|p| p.id}.should == [@photo2.id]
-    @album.photos.all(:order => "desc", :limit => 1).map{|p| p.id}.should == [@photo1.id]
-    @album.photos.all(:order => "asc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
-    @album.photos.all(:order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo2.id]
-
-    @album.photos.find(:all, :order => "asc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
-    @album.photos.find(:all, :order => "desc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    
-    @album.photos.find(:first, :order => "asc").id.should == @photo2.id
-    @album.photos.find(:first, :order => "desc").id.should == @photo1.id
-
-    @album.photos.find(:last, :order => "asc").id.should == @photo1.id
-    @album.photos.find(:last, :order => "desc").id.should == @photo2.id
-        
-    @album.photos.find(:last, :order => "desc", :offset => 2).should == nil
-    @album.photos.find(:first, :order => "desc", :offset => 2).should == nil
-    
-    @album.photos.find(:all, :order => "asc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
-    @album.photos.find(:all, :order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo2.id]
-  end
-
-  it "should delete associated records when :dependant => :destroy in *has_many* assoc" do
-    @album.photos << [@photo1, @photo2]
-
-    @album.photos.count.should == 2
-
-    Photo.count.should == 2
-    @album.destroy
-    Photo.count.should == 0
-    Album.count.should == 0
-  end
-
-  it "should *NOT* delete associated records when :dependant => :nullify or empty in *has_many* assoc" do
-    Photo.count.should == 2
-
-    category = Category.new
-    category.title = "cats"
-    category.save
-
-    Category.count.should == 1
-
-    category.photos << [@photo1, @photo2]
-    category.photos.count.should == 2
-
-    category.destroy
-
-    Photo.count.should == 2
-    Category.count.should == 0
-  end
-
-  it "should delete associated records when :dependant => :destroy and leave them otherwise in *has_one* assoc" do
-    user = User.new
-    user.name = "Dmitrii Samoilov"
-    user.save
-    user.should be
-
-    user.photo = @photo1
-
-    user.photo.id.should == @photo1.id
-
-    User.count.should == 1
-    Photo.count.should == 2
-    user.destroy
-    Photo.count.should == 1
-    User.count.should == 0
-  end
-
-  it "should delete link to associated record when record was deleted" do
-    @album.photos << [@photo1, @photo2]
-
-    @album.photos.count.should == 2
-
-    Photo.count.should == 2
-    @photo1.destroy
-    Photo.count.should == 1
-    
-    @album.photos.count.should == 1
-    @album.photos.size.should == 1
-  end
-end