cached_record 0.1.0

data/test/unit/orm/test_data_mapper.rb

@@ -0,0 +1,616 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+module Unit
+  module ORM
+    class TestDataMapper < MiniTest::Test
+
+      class Article
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_cache :redis
+      end
+
+      class Barticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_cache :redis, :only => [:title, :content]
+      end
+
+      class Carticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_cache :redis, :only => [], :memoize => [:random_array]
+
+        def random_array
+          @random_array ||= [rand(10)]
+        end
+      end
+
+      class Darticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_cache :redis, :only => [:title, :content], :memoize => {:random_array => :@array}
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Earticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_cache :redis, :only => [:title, :content], :memoize => {:random_array => :@array}, :include_root => true
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Farticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        property :content, Text
+        as_memoized_cache :redis, :only => [:title, :content], :memoize => {:random_array => :@array}, :include_root => true
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Garticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        belongs_to :author, :model => "Unit::ORM::TestDataMapper::User"
+        has n, :comments, :model => "Unit::ORM::TestDataMapper::Comment", :child_key => "article_id"
+        has n, :taggings, :model => "Unit::ORM::TestDataMapper::Tagging", :child_key => "article_id"
+        has n, :tags, :through => :taggings
+        as_memoized_cache :redis, :only => [:title], :include => [:author, :comments, :tags]
+      end
+
+      class User
+        include DataMapper::Resource
+        storage_names[:default] = "users"
+        property :id, Serial, :key => true
+        property :name, String
+        has 1, :foo, :model => "Unit::ORM::TestDataMapper::Article", :child_key => "foo_id"
+        as_memoized_cache :memcached, :only => [:name], :include => [:foo]
+      end
+
+      class Comment
+        include DataMapper::Resource
+        storage_names[:default] = "comments"
+        property :id, Serial, :key => true
+        property :content, Text
+        belongs_to :article, :model => "Unit::ORM::TestDataMapper::Garticle"
+        belongs_to :poster, :model => "Unit::ORM::TestDataMapper::User"
+        as_memoized_cache :redis, :only => [:content], :include => [:poster]
+      end
+
+      class Tag
+        include DataMapper::Resource
+        storage_names[:default] = "tags"
+        property :id, Serial, :key => true
+        property :name, String
+        has n, :articles, :model => "Unit::ORM::TestDataMapper::Garticle", :through => Resource
+        as_memoized_cache :redis, :only => [:name]
+      end
+
+      class Tagging
+        include DataMapper::Resource
+        storage_names[:default] = "articles_tags"
+        property :id, Serial, :key => true
+        belongs_to :article, :model => "Unit::ORM::TestDataMapper::Garticle"
+        belongs_to :tag, :model => "Unit::ORM::TestDataMapper::Tag"
+      end
+
+      class Harticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        as_memoized_cache :redis, :only => [:title], :expire => 2.seconds
+      end
+
+      class Jarticle
+        include DataMapper::Resource
+        storage_names[:default] = "articles"
+        property :id, Serial, :key => true
+        property :title, String
+        as_memoized_cache :redis, :only => [:title], :retain => 4.seconds
+      end
+
+      DataMapper.finalize
+
+      describe CachedRecord::ORM::DataMapper do
+        describe "when DataMapper is not defined" do
+          it "knows not to setup DataMapper::Resource" do
+            CachedRecord::ORM::DataMapper.expects(:setup?).returns false
+            DataMapper::Resource.expects(:send).with(:include, CachedRecord::ORM::InstanceMethods).never
+            DataMapper::Resource.expects(:send).with(:include, CachedRecord::ORM::DataMapper::InstanceMethods).never
+            CachedRecord::ORM::DataMapper.setup
+          end
+        end
+
+        describe "when DataMapper is defined" do
+          it "knows to setup DataMapper::Resource" do
+            CachedRecord::ORM::DataMapper.expects(:setup?).returns true
+            DataMapper::Resource.expects(:send).with(:include, CachedRecord::ORM::InstanceMethods)
+            DataMapper::Resource.expects(:send).with(:include, CachedRecord::ORM::DataMapper::InstanceMethods)
+            CachedRecord::ORM::DataMapper.setup
+          end
+        end
+
+        describe "DataMapper::Resource included" do
+          before do
+            @redis = Redis.new
+            @memcached = Dalli::Client.new
+          end
+
+          describe "Article" do
+            it "returns its cache JSON hash" do
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries",
+                :foo_id => 2
+              }, Article.get(1).as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Article.cached 1
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries",
+                :foo_id => 2
+              }, @redis.get("unit.orm.test_data_mapper.article.1"))
+            end
+            it "can be fetched from the cache store" do
+              Article.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.article.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries"
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries",
+                :foo_id => 2
+              }, Article.cached(1).attributes)
+            end
+            it "is not a new" do
+              assert_equal false, Article.cached(1).new?
+            end
+          end
+
+          describe "Barticle" do
+            it "returns its cache JSON hash" do
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Barticle.get(1).as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Barticle.cached(1)
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, @redis.get("unit.orm.test_data_mapper.barticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Barticle.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.barticle.1", {
+                  "id" => 1,
+                  "title" => "Behold! It's CachedRecord!",
+                  "content" => "Cache ORM instances to avoid database queries"
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Barticle.cached(1).attributes)
+            end
+          end
+
+          describe "Carticle" do
+            it "returns its cache JSON hash" do
+              c = Carticle.get(1)
+              c.expects(:rand).returns(5)
+              assert_equal_hashes({
+                :id => 1,
+                :@random_array => [5]
+              }, c.as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Carticle.any_instance.expects(:rand).returns(4)
+              Carticle.cached(1)
+              assert_equal_hashes({
+                :id => 1,
+                :@random_array => [4]
+              }, @redis.get("unit.orm.test_data_mapper.carticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Carticle.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.carticle.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries",
+                  :@random_array => [3]
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Carticle.cached(1).attributes)
+              assert_equal(
+                true, Carticle.cached(1).instance_variables.include?(:@random_array)
+              )
+              assert_equal([
+                3
+              ], Carticle.cached(1).instance_variable_get(:@random_array))
+            end
+          end
+
+          describe "Darticle" do
+            it "returns its cache JSON hash" do
+              d = Darticle.get(1)
+              d.expects(:rand).returns(5)
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries",
+                :@array => [5]
+              }, d.as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Darticle.any_instance.expects(:rand).returns(4)
+              Darticle.cached(1)
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries",
+                :@array => [4]
+              }.to_json, @redis.get("unit.orm.test_data_mapper.darticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Darticle.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.darticle.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries",
+                  :@array => [3]
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Darticle.cached(1).attributes)
+              assert_equal(
+                true, Darticle.cached(1).instance_variables.include?(:@array)
+              )
+              assert_equal([
+                3
+              ], Darticle.cached(1).instance_variable_get(:@array))
+            end
+          end
+
+          describe "Earticle" do
+            it "returns its cache JSON hash" do
+              e = Earticle.get(1)
+              e.expects(:rand).returns(5)
+              assert_equal_hashes({
+                :earticle => {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries"
+                },
+                :array => [5]
+              }, e.as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Earticle.any_instance.expects(:rand).returns(4)
+              Earticle.cached(1)
+              assert_equal_hashes({
+                :earticle => {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries"
+                },
+                :array => [4]
+              }, @redis.get("unit.orm.test_data_mapper.earticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Earticle.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.earticle.1", {
+                  :earticle => {
+                    :id => 1,
+                    :title => "Behold! It's CachedRecord!",
+                    :content => "Cache ORM instances to avoid database queries"
+                  },
+                  :array => [3]
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Earticle.cached(1).attributes)
+              assert_equal(
+                true, Earticle.cached(1).instance_variables.include?(:@array)
+              )
+              assert_equal([
+                3
+              ], Earticle.cached(1).instance_variable_get(:@array))
+            end
+            it "is not memoized" do
+              assert_equal false, (Earticle.cached(1).object_id == Earticle.cached(1).object_id)
+            end
+          end
+
+          describe "Farticle" do
+            it "can be fetched from the cache store" do
+              Farticle.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.farticle.1", {
+                  :farticle => {
+                    :id => 1,
+                    :title => "Behold! It's CachedRecord!",
+                    :content => "Cache ORM instances to avoid database queries"
+                  },
+                  :array => [3]
+                }.to_json
+              )
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :content => "Cache ORM instances to avoid database queries"
+              }, Farticle.cached(1).attributes)
+              assert_equal(
+                true, Farticle.cached(1).instance_variables.include?(:@array)
+              )
+              assert_equal([
+                3
+              ], Farticle.cached(1).instance_variable_get(:@array))
+            end
+            it "is memoized" do
+              assert_equal Farticle.cached(1).object_id, Farticle.cached(1).object_id
+              assert_equal Farticle.cached(1).object_id, Farticle.cached(1).object_id
+            end
+          end
+
+          describe "Garticle" do
+            it "returns its cache JSON hash" do
+              g = Garticle.get(1)
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :author_id => 1,
+                :_comment_ids => [1, 2],
+                :_tag_ids => [1, 2]
+              }, g.as_cache_json)
+            end
+            it "can be stored in the cache store" do
+              Garticle.cached(1)
+              assert_equal_hashes({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :author_id => 1,
+                :_comment_ids => [1, 2],
+                :_tag_ids => [1, 2]
+              }, @redis.get("unit.orm.test_data_mapper.garticle.1"))
+              assert_equal_hashes({
+                :id => 1,
+                :name => "Paul Engel",
+                :_foo_id => nil
+              }, @memcached.get("unit.orm.test_data_mapper.user.1"))
+              assert_equal_hashes({
+                :id => 2,
+                :name => "Ken Adams",
+                :_foo_id => 1
+              }, @memcached.get("unit.orm.test_data_mapper.user.2"))
+              assert_equal_hashes({
+                :id => 1,
+                :content => "What a great article! :)",
+                :poster_id => 2
+              }, @redis.get("unit.orm.test_data_mapper.comment.1"))
+              assert_equal_hashes({
+                :id => 2,
+                :content => "Thanks!",
+                :poster_id => 1
+              }, @redis.get("unit.orm.test_data_mapper.comment.2"))
+            end
+            it "can be fetched from the cache store" do
+              Garticle.expects(:get).never
+              User.expects(:get).never
+              Comment.expects(:get).never
+              Tag.expects(:get).never
+              @redis.set(
+                "unit.orm.test_data_mapper.garticle.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :author_id => 1,
+                  :_comment_ids => [1, 2],
+                  :_tag_ids => [1, 2]
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_data_mapper.user.1", {
+                  :id => 1,
+                  :name => "Paul Engel"
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_data_mapper.user.2", {
+                  :id => 2,
+                  :name => "Ken Adams"
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_data_mapper.comment.1", {
+                  :id => 1,
+                  :content => "What a great article! :)",
+                  :poster_id => 2
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_data_mapper.comment.2", {
+                  :id => 2,
+                  :content => "Thanks!",
+                  :poster_id => 1
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_data_mapper.tag.1", {
+                  :id => 1,
+                  :name => "ruby"
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_data_mapper.tag.2", {
+                  :id => 2,
+                  :name => "gem"
+                }.to_json
+              )
+              g = Garticle.cached(1)
+              assert_equal({
+                :id => 1,
+                :title => "Behold! It's CachedRecord!",
+                :author_id => 1
+              }, g.attributes)
+              assert_equal({
+                :id => 1,
+                :name => "Paul Engel"
+              }, g.author.attributes)
+              assert_equal([{
+                :id => 1,
+                :name => "ruby"
+              }, {
+                :id => 2,
+                :name => "gem"
+              }], g.tags.collect(&:attributes))
+              assert_equal([{
+                :id => 1,
+                :content => "What a great article! :)",
+                :article_id => 1,
+                :poster_id => 2
+              }, {
+                :id => 2,
+                :content => "Thanks!",
+                :article_id => 1,
+                :poster_id => 1
+              }], g.comments.collect(&:attributes))
+              assert_equal([{
+                :id => 2,
+                :name => "Ken Adams"
+              }, {
+                :id => 1,
+                :name => "Paul Engel"
+              }], g.comments.collect{|x| x.poster.attributes})
+              assert_equal g.author.object_id, g.comments[1].poster.object_id
+            end
+          end
+
+          describe "Harticle" do
+            it "has the expected as cache options" do
+              assert_equal_hashes({
+                :store => :redis,
+                :expire => 2.seconds,
+                :as_json => {:only => [:title]},
+                :memoize => true
+              }, Harticle.as_cache)
+            end
+            it "expires after 2 seconds" do
+              object_id = Harticle.cached(1).object_id
+              assert_equal object_id, Harticle.cached(1).object_id
+              assert_equal object_id, Harticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Harticle.cached(1).object_id
+              assert_equal object_id, Harticle.cached(1).object_id
+              sleep 1.5
+              assert_equal false, object_id == Harticle.cached(1).object_id
+            end
+          end
+
+          describe "Jarticle" do
+            it "has the expected as cache options" do
+              assert_equal_hashes({
+                :store => :redis,
+                :as_json => {:only => [:title]},
+                :memoize => true,
+                :retain => 4.seconds
+              }, Jarticle.as_cache)
+            end
+            it "does not hit the cache for 4 seconds" do
+              object_id = Jarticle.cached(1).object_id
+              cached = CachedRecord::Cache.send(:stores)[:redis].get Jarticle.cache_key(1)
+
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).never
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).returns(cached)
+              sleep 1.5
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).never
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).returns(cached)
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).never
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.expire Jarticle.cached(1)
+              CachedRecord::Cache.send(:stores)[:redis].expects(:get).returns(cached)
+              assert_equal false, object_id == Jarticle.cached(1).object_id
+            end
+          end
+        end
+      end
+
+    end
+  end
+end