cached_record 0.1.0

data/test/unit/orm/test_active_record.rb

@@ -0,0 +1,628 @@
+require File.expand_path("../../../test_helper", __FILE__)
+
+module Unit
+  module ORM
+    class TestActiveRecord < MiniTest::Test
+
+      class Article < ActiveRecord::Base
+        as_cache :memcached
+      end
+
+      class Barticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_cache :memcached, :only => [:title, :content]
+      end
+
+      class Carticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_cache :memcached, :only => [], :memoize => [:random_array]
+
+        def random_array
+          @random_array ||= [rand(10)]
+        end
+      end
+
+      class Darticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_cache :memcached, :only => [:title, :content], :memoize => {:random_array => :@array}
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Earticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_cache :memcached, :only => [:title, :content], :memoize => {:random_array => :@array}, :include_root => true
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Farticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_memoized_cache :memcached, :only => [:title, :content], :memoize => {:random_array => :@array}, :include_root => true
+
+        def random_array
+          @array ||= [rand(10)]
+        end
+      end
+
+      class Garticle < ActiveRecord::Base
+        self.table_name = "articles"
+        belongs_to :author, :class_name => "Unit::ORM::TestActiveRecord::User"
+        has_many :comments, :class_name => "Unit::ORM::TestActiveRecord::Comment", :foreign_key => "article_id"
+        has_and_belongs_to_many :tags, :class_name => "Unit::ORM::TestActiveRecord::Tag", :join_table => "articles_tags", :foreign_key => "article_id"
+        as_memoized_cache :memcached, :only => [:title], :include => [:author, :comments, :tags]
+      end
+
+      class User < ActiveRecord::Base
+        has_one :foo, :class_name => "Unit::ORM::TestActiveRecord::Article", :foreign_key => "foo_id"
+        as_memoized_cache :redis, :only => [:name], :include => [:foo]
+      end
+
+      class Comment < ActiveRecord::Base
+        belongs_to :article, :class_name => "Unit::ORM::TestActiveRecord::Garticle"
+        belongs_to :poster, :class_name => "Unit::ORM::TestActiveRecord::User"
+        as_memoized_cache :memcached, :only => [:content], :include => [:poster]
+      end
+
+      class Tag < ActiveRecord::Base
+        has_and_belongs_to_many :articles, :class_name => "Unit::ORM::TestActiveRecord::Garticle", :join_table => "articles_tags", :foreign_key => "tag_id"
+        as_memoized_cache :memcached, :only => [:name]
+      end
+
+      class Harticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_memoized_cache :memcached, :only => [:title], :expire => 2.seconds
+      end
+
+      class Jarticle < ActiveRecord::Base
+        self.table_name = "articles"
+        as_memoized_cache :memcached, :only => [:title], :retain => 4.seconds
+      end
+
+      describe CachedRecord::ORM::ActiveRecord do
+        describe "when ActiveRecord is not defined" do
+          it "knows not to setup ActiveRecord::Base" do
+            CachedRecord::ORM::ActiveRecord.expects(:setup?).returns false
+            ActiveRecord::Base.expects(:extend).with(CachedRecord::ORM::ActiveRecord::ClassMethods).never
+            ActiveRecord::Base.expects(:send).with(:include, CachedRecord::ORM).never
+            ActiveRecord::Base.expects(:send).with(:include, CachedRecord::ORM::ActiveRecord::InstanceMethods).never
+            CachedRecord::ORM::ActiveRecord.setup
+          end
+        end
+
+        describe "when ActiveRecord is defined" do
+          it "knows to setup ActiveRecord::Base" do
+            CachedRecord::ORM::ActiveRecord.expects(:setup?).returns true
+            ActiveRecord::Base.expects(:extend).with(CachedRecord::ORM::ActiveRecord::ClassMethods)
+            ActiveRecord::Base.expects(:send).with(:include, CachedRecord::ORM)
+            ActiveRecord::Base.expects(:send).with(:include, CachedRecord::ORM::ActiveRecord::InstanceMethods)
+            CachedRecord::ORM::ActiveRecord.setup
+          end
+        end
+
+        describe "ActiveRecord::Base instances" do
+          before do
+            @memcached = Dalli::Client.new
+            @redis = Redis.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",
+                :author_id => 1,
+                :foo_id => 2,
+                :published_at => Time.parse("2013-08-01 12:00:00"),
+                :created_at => Time.parse("2013-08-01 10:00:00"),
+                :updated_at => Time.parse("2013-08-01 11:00:00")
+              }, Article.find(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",
+                :author_id => 1,
+                :foo_id => 2,
+                :published_at => Time.parse("2013-08-01 12:00:00"),
+                :created_at => Time.parse("2013-08-01 10:00:00"),
+                :updated_at => Time.parse("2013-08-01 11:00:00")
+              }, @memcached.get("unit.orm.test_active_record.article.1"))
+            end
+            it "can be fetched from the cache store" do
+              Article.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.article.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :content => "Cache ORM instances to avoid database queries",
+                  :author_id => 1,
+                  :foo_id => 2,
+                  :published_at => Time.parse("2013-08-01 12:00:00"),
+                  :created_at => Time.parse("2013-08-01 10:00:00"),
+                  :updated_at => Time.parse("2013-08-01 11:00:00")
+                }.to_json
+              )
+              assert_equal_hashes({
+                "id" => 1,
+                "title" => "Behold! It's CachedRecord!",
+                "content" => "Cache ORM instances to avoid database queries",
+                "author_id" => 1,
+                "foo_id" => 2,
+                "published_at" => Time.parse("2013-08-01 12:00:00"),
+                "created_at" => Time.parse("2013-08-01 10:00:00"),
+                "updated_at" => Time.parse("2013-08-01 11:00:00")
+              }, Article.cached(1).attributes)
+            end
+            it "is not a new record" do
+              assert_equal false, Article.cached(1).new_record?
+            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.find(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"
+              }, @memcached.get("unit.orm.test_active_record.barticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Barticle.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.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",
+                "author_id" => nil,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, Barticle.cached(1).attributes)
+            end
+          end
+
+          describe "Carticle" do
+            it "returns its cache JSON hash" do
+              c = Carticle.find(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]
+              }, @memcached.get("unit.orm.test_active_record.carticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Carticle.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.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",
+                "author_id" => nil,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, 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.find(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]
+              }, @memcached.get("unit.orm.test_active_record.darticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Darticle.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.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",
+                "author_id" => nil,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, 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.find(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]
+              }, @memcached.get("unit.orm.test_active_record.earticle.1"))
+            end
+            it "can be fetched from the cache store" do
+              Earticle.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.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",
+                "author_id" => nil,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, 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(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.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",
+                "author_id" => nil,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, 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.find(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]
+              }, @memcached.get("unit.orm.test_active_record.garticle.1"))
+              assert_equal_hashes({
+                :id => 1,
+                :name => "Paul Engel",
+                :_foo_id => nil
+              }, @redis.get("unit.orm.test_active_record.user.1"))
+              assert_equal_hashes({
+                :id => 2,
+                :name => "Ken Adams",
+                :_foo_id => 1
+              }, @redis.get("unit.orm.test_active_record.user.2"))
+              assert_equal_hashes({
+                :id => 1,
+                :content => "What a great article! :)",
+                :poster_id => 2
+              }, @memcached.get("unit.orm.test_active_record.comment.1"))
+              assert_equal_hashes({
+                :id => 2,
+                :content => "Thanks!",
+                :poster_id => 1
+              }, @memcached.get("unit.orm.test_active_record.comment.2"))
+            end
+            it "can be fetched from the cache store" do
+              Garticle.expects(:find).never
+              User.expects(:find).never
+              Comment.expects(:find).never
+              Tag.expects(:find).never
+              @memcached.set(
+                "unit.orm.test_active_record.garticle.1", {
+                  :id => 1,
+                  :title => "Behold! It's CachedRecord!",
+                  :author_id => 1,
+                  :_comment_ids => [1, 2],
+                  :_tag_ids => [1, 2]
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_active_record.user.1", {
+                  :id => 1,
+                  :name => "Paul Engel"
+                }.to_json
+              )
+              @redis.set(
+                "unit.orm.test_active_record.user.2", {
+                  :id => 2,
+                  :name => "Ken Adams"
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_active_record.comment.1", {
+                  :id => 1,
+                  :content => "What a great article! :)",
+                  :poster_id => 2
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_active_record.comment.2", {
+                  :id => 2,
+                  :content => "Thanks!",
+                  :poster_id => 1
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_active_record.tag.1", {
+                  :id => 1,
+                  :name => "ruby"
+                }.to_json
+              )
+              @memcached.set(
+                "unit.orm.test_active_record.tag.2", {
+                  :id => 2,
+                  :name => "gem"
+                }.to_json
+              )
+              g = Garticle.cached(1)
+              assert_equal({
+                "id" => 1,
+                "title" => "Behold! It's CachedRecord!",
+                "content" => nil,
+                "author_id" => 1,
+                "foo_id" => nil,
+                "published_at" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, g.attributes)
+              assert_equal({
+                "id" => 1,
+                "name" => "Paul Engel",
+                "description" => nil,
+                "active" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, g.author.attributes)
+              assert_equal([{
+                "id" => 1,
+                "name" => "ruby",
+                "created_at" => nil,
+                "updated_at" => nil
+              }, {
+                "id" => 2,
+                "name" => "gem",
+                "created_at" => nil,
+                "updated_at" => nil
+              }], g.tags.collect(&:attributes))
+              assert_equal([{
+                "id" => 1,
+                "content" => "What a great article! :)",
+                "article_id" => nil,
+                "poster_id" => 2,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, {
+                "id" => 2,
+                "content" => "Thanks!",
+                "article_id" => nil,
+                "poster_id" => 1,
+                "created_at" => nil,
+                "updated_at" => nil
+              }], g.comments.collect(&:attributes))
+              assert_equal([{
+                "id" => 2,
+                "name" => "Ken Adams",
+                "description" => nil,
+                "active" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }, {
+                "id" => 1,
+                "name" => "Paul Engel",
+                "description" => nil,
+                "active" => nil,
+                "created_at" => nil,
+                "updated_at" => nil
+              }], 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 => :memcached,
+                :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 => :memcached,
+                :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)[:memcached].get Jarticle.cache_key(1)
+
+              CachedRecord::Cache.send(:stores)[:memcached].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)[:memcached].expects(:get).returns(cached)
+              sleep 1.5
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:memcached].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)[:memcached].expects(:get).returns(cached)
+              sleep 1
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.send(:stores)[:memcached].expects(:get).never
+              assert_equal object_id, Jarticle.cached(1).object_id
+
+              CachedRecord::Cache.expire Jarticle.cached(1)
+              CachedRecord::Cache.send(:stores)[:memcached].expects(:get).returns(cached)
+              assert_equal false, object_id == Jarticle.cached(1).object_id
+            end
+          end
+        end
+      end
+
+    end
+  end
+end