mongoid_ext 0.6.1

data/test/test_modifiers.rb

@@ -0,0 +1,65 @@
+require 'helper'
+
+class ModifiersTest < Test::Unit::TestCase
+  context "Modifying documents" do
+    setup do
+      @entry = Entry.create(:v => 345)
+    end
+
+    should "increment the value" do
+      Entry.increment({:_id => @entry.id}, {:v => 1})
+      @entry.reload
+      @entry.v.should == 346
+    end
+
+    should "decrement the value" do
+      @entry.decrement(:v => 1)
+      @entry.reload
+      @entry.v.should == 344
+    end
+
+    should "override the value" do
+      @entry.override(:v => 543)
+      @entry.reload
+      @entry.v.should == 543
+    end
+
+    should "unset the value" do
+      @entry.unset(:v => true)
+      @entry.reload
+      @entry.v.should == nil
+    end
+
+    should "push a value" do
+      @entry.push(:a => 1)
+      @entry.reload
+      @entry.a.should == [1]
+    end
+
+    should "not duplicate the value" do
+      @entry.push_uniq(:a => 1)
+      @entry.push_uniq(:a => 1)
+      @entry.push_uniq(:a => 1)
+      @entry.reload
+      @entry.a.should == [1]
+    end
+
+    should "pull a value" do
+      @entry.push_uniq(:a => 1)
+      @entry.push_uniq(:a => 2)
+      @entry.push_uniq(:a => 3)
+      @entry.pull(:a => 2)
+      @entry.reload
+      @entry.a.should == [1, 3]
+    end
+
+    should "pop the last value" do
+      @entry.push_uniq(:a => 1)
+      @entry.push_uniq(:a => 2)
+      @entry.push_uniq(:a => 3)
+      @entry.pop(:a => 1)
+      @entry.reload
+      @entry.a.should == [1, 2]
+    end
+  end
+end

data/test/test_paranoia.rb

@@ -0,0 +1,40 @@
+require 'helper'
+
+class TestParanoia < Test::Unit::TestCase
+  context "working with versions" do
+    setup do
+      User.delete_all
+      User.deleted.delete_all
+
+      @user = User.create(:login => "foo",
+                          :email => "foo@bar.baz")
+    end
+
+    should "not delete permanently the record" do
+      @user.destroy
+      User.deleted.count.should == 1
+      User.count.should == 0
+    end
+
+    should "restore the deleted record" do
+      @user.destroy
+      User.deleted.first.restore.email.should == "foo@bar.baz"
+    end
+
+    should "delete the old records" do
+      @user.destroy
+      deleted = User.deleted.first
+      deleted.created_at = 2.months.ago
+      deleted.save
+
+      User.deleted.compact!
+      User.deleted.count.should == 0
+    end
+
+    should "find the record using the original id" do
+      id = @user.id
+      @user.destroy
+      User.deleted.find(id).should_not be_nil
+    end
+  end
+end

data/test/test_random.rb

@@ -0,0 +1,57 @@
+require 'helper'
+
+class TestRandom < Test::Unit::TestCase
+  context "working with tags" do
+    setup do
+    end
+
+    should "find a random entry" do
+      Entry.random.should_not be_nil
+      Entry.random.should_not be_nil
+      Entry.random.should_not be_nil
+    end
+
+    should "increment the counter" do
+      entry = Entry.random
+      entry._random_times.should > 0
+    end
+
+    should "allow to pass conditions" do
+      entry = Entry.random(:v => 10)
+      entry.v.should == 10
+    end
+
+#
+#     should "generate the tagcloud" do
+#       cloud = BlogPost.tag_cloud
+#
+#       [{"name"=>"list", "count"=>2.0},
+#        {"name"=>"windows", "count"=>1.0},
+#        {"name"=>"freebsd", "count"=>1.0},
+#        {"name"=>"osx", "count"=>1.0},
+#        {"name"=>"linux", "count"=>1.0},
+#        {"name"=>"mongodb", "count"=>1.0},
+#        {"name"=>"redis", "count"=>1.0},
+#        {"name"=>"couchdb", "count"=>1.0}].each do |entry|
+#         cloud.should include(entry)
+#       end
+#     end
+#
+#     should "find blogpost that include the given tags" do
+#       BlogPost.find_with_tags("mongodb").to_a.should == [@blogpost2]
+#       posts = BlogPost.find_with_tags("mongodb", "linux").to_a
+#       posts.should include(@blogpost)
+#       posts.should include(@blogpost2)
+#       posts.size.should == 2
+#     end
+#
+#     should "find tags that start with li" do
+#       tags = BlogPost.find_tags(/^li/)
+#       [{"name"=>"list", "count"=>2.0}, {"name"=>"linux", "count"=>1.0}].each do |entry|
+#         tags.should include(entry)
+#       end
+#       tags.size.should == 2
+#     end
+
+  end
+end

data/test/test_slugizer.rb

@@ -0,0 +1,66 @@
+require 'helper'
+
+class TestSlugizer < Test::Unit::TestCase
+  context "working with slugs" do
+    setup do
+      BlogPost.delete_all
+      @blogpost = BlogPost.create(:title => "%bLog pOSt tiTLe!",
+                                  :body => "HeRe is tHe Body of the bLog pOsT")
+    end
+
+    should "generate the slug" do
+      @blogpost.slug.should =~ /\w+-blog-post-title/
+    end
+
+    should "not generate the slug if the slug key is blank" do
+      @empty_blogpost = BlogPost.new
+      @empty_blogpost.slug.should be_nil
+    end
+
+    should "return the slug as param" do
+      @blogpost.to_param =~ /\w+-blog-post-title/
+    end
+
+    should "return the id if slug was not generated" do
+      @blogpost.slug = nil
+      @blogpost.to_param.should == @blogpost.id.to_s
+    end
+
+    should "respect the max length option" do
+      @blogpost = BlogPost.create(:title => "ultimo video/cancion en youtube?",
+                                  :body => "HeRe is tHe Body of the bLog pOsT")
+      @blogpost.slug.should =~ /\w+-ultimo-video-canci/
+    end
+
+    should "not accept slugs with length < :min_length" do
+      @blogpost = BlogPost.create(:title => "a",
+                                  :body => "HeRe is tHe Body of the bLog pOsT")
+      @blogpost.slug.should be_nil
+    end
+
+    should "update the slug after updating the object" do
+      @blogpost = BlogPost.create(:title => "ultimo video/cancion en youtube?",
+                                  :body => "HeRe is tHe Body of the bLog pOsT")
+      @blogpost.slug.should =~ /\w+-ultimo-video-canci/
+      @blogpost.title = "primer video/cancion en youtube?"
+      @blogpost.valid?
+      @blogpost.slug.should =~ /\w+-primer-video-canci/
+    end
+  end
+
+  context "finding objects" do
+    setup do
+      BlogPost.delete_all
+      @blogpost = BlogPost.create(:title => "%bLog pOSt tiTLe!",
+                                  :body => "HeRe is tHe Body of the bLog pOsT")
+    end
+
+    should "be able to find by slug" do
+      BlogPost.by_slug(@blogpost.slug).should == @blogpost
+    end
+
+    should "be able to find by id" do
+      BlogPost.by_slug(@blogpost.id).should == @blogpost
+    end
+  end
+end

data/test/test_storage.rb

@@ -0,0 +1,110 @@
+require 'helper'
+
+class StorageTest < Test::Unit::TestCase
+  context "Storing files" do
+    setup do
+      @avatar = Avatar.create
+      @data = StringIO.new("my avatar image")
+    end
+
+    should "store the file" do
+      @avatar.put_file("an_avatar.png", @data)
+      @avatar.save
+      avatar = Avatar.find(@avatar.id)
+      data = avatar.fetch_file("an_avatar.png").read
+      data.should == "my avatar image"
+    end
+
+    should "not close the file after storing" do
+      @avatar.put_file("an_avatar.png", @data)
+      @data.should_not be_closed
+    end
+
+    context "in attributes" do
+      should "store the given file" do
+        @avatar.data = @data
+        @avatar.save!
+        @avatar.data.should_not be_nil
+        @avatar.data.read.should == "my avatar image"
+      end
+    end
+
+    context "with new objects" do
+      setup do
+        @avatar = Avatar.new
+      end
+
+      should "store the data correctly" do
+        @avatar.data = @data
+        @avatar.save
+        @avatar = Avatar.find(@avatar.id)
+        @avatar.data.read.should == "my avatar image"
+      end
+
+      should "store the file after saving" do
+        @avatar.put_file("an_avatar.png", @data)
+        @avatar.save
+        @avatar.fetch_file("an_avatar.png").read.should == "my avatar image"
+      end
+
+      should "not store the file if object is new" do
+        @avatar.put_file("an_avatar.png", @data)
+        lambda {@avatar.fetch_file("an_avatar.png").read}.should raise_error
+      end
+    end
+
+    context "with lists" do
+      setup do
+        @avatar = Avatar.new
+        @alternative = File.new(__FILE__)
+        @data = File.read(__FILE__)
+      end
+      teardown do
+        @alternative.close
+      end
+
+      should "store the file" do
+        @avatar.first_alternative = @alternative
+        @avatar.save
+        fromdb = @avatar.reload
+        fromdb.first_alternative.read.should == @data
+      end
+
+      should "store the file in the alternative list" do
+        @avatar.alternatives.put("an_alternative", @alternative)
+        @avatar.save
+        @avatar.reload
+        @avatar.alternatives.get("an_alternative").read.should == @data
+      end
+    end
+  end
+
+  context "Fetching files" do
+    setup do
+      @avatar = Avatar.create
+      @data = StringIO.new("my avatar image")
+    end
+
+    should "fetch the list of files" do
+      @avatar.put_file("file1", StringIO.new("data1"))
+      @avatar.put_file("file2", StringIO.new("data2"))
+      @avatar.put_file("file3", StringIO.new("data3"))
+      file_names = @avatar.files.map { |f| f.filename }
+      file_names.size.should == 3
+      file_names.should include("file1")
+      file_names.should include("file2")
+      file_names.should include("file3")
+    end
+
+   should "iterate the list of files" do
+      @avatar.put_file("file1", StringIO.new("data1"))
+      @avatar.put_file("file2", StringIO.new("data2"))
+      @avatar.put_file("file3", StringIO.new("data3"))
+      file_names = %w[file1 file2 file3]
+      @avatar.file_list.each_file do |key, file|
+        file_names.should include key
+        file_names.should include file.filename
+      end
+   end
+  end
+end

data/test/test_tags.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+class TestTags < Test::Unit::TestCase
+  context "working with tags" do
+    setup do
+      BlogPost.delete_all
+      @blogpost = BlogPost.create(:title => "operation systems",
+                                  :body => "list of some operating systems",
+                                  :tags => %w[list windows freebsd osx linux])
+      @blogpost2 = BlogPost.create(:title => "nosql database",
+                                   :body => "list of some nosql databases",
+                                   :tags => %w[list mongodb redis couchdb])
+    end
+
+    should "generate the tagcloud" do
+      cloud = BlogPost.tag_cloud
+
+      [{"name"=>"list", "count"=>2.0},
+       {"name"=>"windows", "count"=>1.0},
+       {"name"=>"freebsd", "count"=>1.0},
+       {"name"=>"osx", "count"=>1.0},
+       {"name"=>"linux", "count"=>1.0},
+       {"name"=>"mongodb", "count"=>1.0},
+       {"name"=>"redis", "count"=>1.0},
+       {"name"=>"couchdb", "count"=>1.0}].each do |entry|
+        cloud.should include(entry)
+      end
+    end
+
+    should "find blogpost that include the given tags" do
+      BlogPost.find_with_tags("mongodb").to_a.should == [@blogpost2]
+      posts = BlogPost.find_with_tags("mongodb", "linux").to_a
+      posts.should include(@blogpost)
+      posts.should include(@blogpost2)
+      posts.size.should == 2
+    end
+
+    should "find tags that start with li" do
+      tags = BlogPost.find_tags(/^li/)
+      [{"name"=>"list", "count"=>2.0}, {"name"=>"linux", "count"=>1.0}].each do |entry|
+        tags.should include(entry)
+      end
+      tags.size.should == 2
+    end
+
+  end
+end

data/test/test_update.rb

@@ -0,0 +1,16 @@
+require 'helper'
+
+class UpdateTest < Test::Unit::TestCase
+  should "only update the given white listed attributes" do
+    event = Event.new(:password => "original")
+    start_date = Time.zone.now
+    end_date = start_date.tomorrow
+
+    event.safe_update(%w[start_date end_date], {"start_date" => start_date,
+                                                "end_date" => end_date,
+                                                "password" => "hacked"})
+    event.password.should == "original"
+    event.start_date.to_s.should == start_date.to_s
+    event.end_date.to_s.should == end_date.to_s
+  end
+end

data/test/test_versioning.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+class TestVersioning < Test::Unit::TestCase
+  context "working with versions" do
+    setup do
+      BlogPost.delete_all
+      User.delete_all
+
+      @blogpost = BlogPost.create(:title => "operating systems",
+                                  :body => "list of some operating systems",
+                                  :tags => %w[list windows freebsd osx linux],
+                                  :updated_by => User.create(:login => "foo"))
+    end
+
+    should "generate a new version" do
+      @blogpost.versions_count.should == 0
+      @blogpost.title = "sistemas operativos"
+      @blogpost.save!
+      @blogpost.reload
+      @blogpost.versions_count.should == 1
+    end
+
+    should "be able to generate a diff between versions" do
+      @blogpost.title = "sistemas operativos"
+      @blogpost.save!
+      @blogpost.reload
+
+      @blogpost.diff(:title, "current", 0, :ascii).should == '{+"sistemas operativos"}'
+      @blogpost.diff(:title, 0, "current", :ascii).should == '{-"sistemas operativos"}'
+    end
+
+    should "be able to restore a previous version" do
+      @blogpost.title = "sistemas operativos"
+      @blogpost.save!
+      @blogpost.reload
+
+      @blogpost.title.should == "sistemas operativos"
+      @blogpost.rollback!(0)
+      @blogpost.title.should == "operating systems"
+    end
+
+    should "respect the max versions limit" do
+      @blogpost.title = "sistemas operativos"
+      @blogpost.save!
+      @blogpost.reload
+      @blogpost.title = "sistemas operativos 2"
+      @blogpost.save!
+      @blogpost.reload
+      @blogpost.title = "sistemas operativos 3"
+      @blogpost.save!
+      @blogpost.reload
+      @blogpost.versions.count.should == 2
+    end
+  end
+end