cached_record 0.1.0

data/test/unit/test_cache.rb

@@ -0,0 +1,351 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestCache < MiniTest::Test
+
+    describe CachedRecord::Cache do
+      after do
+        CachedRecord::Cache.instance_variable_set :@stores, nil
+      end
+
+      describe ".memcached" do
+        after do
+          Dalli::Client.unstub :new
+        end
+        it "initiates a Dalli::Client instance" do
+          Dalli::Client.expects(:new).with "127.0.0.1:11211", {}
+          CachedRecord::Cache.memcached :host => "127.0.0.1"
+        end
+        it "memoizes a Dalli::Client instance" do
+          client = mock
+          Dalli::Client.expects(:new).returns client
+          CachedRecord::Cache.memcached
+          assert_equal CachedRecord::Cache.memcached.object_id, client.object_id
+          assert_equal CachedRecord::Cache.memcached.object_id, client.object_id
+        end
+      end
+
+      describe ".redis" do
+        after do
+          Redis.unstub :new
+        end
+        it "initiates a Redis instance" do
+          Redis.expects(:new).with :host => "127.0.0.1"
+          CachedRecord::Cache.redis :host => "127.0.0.1"
+        end
+        it "memoizes a Redis instance" do
+          client = mock
+          Redis.expects(:new).returns client
+          CachedRecord::Cache.redis
+          assert_equal CachedRecord::Cache.redis.object_id, client.object_id
+          assert_equal CachedRecord::Cache.redis.object_id, client.object_id
+        end
+      end
+
+      describe "cache store" do
+        describe ".valid_store?" do
+          it "returns whether the passed argument is a valid cache store" do
+            assert_equal true, CachedRecord::Cache.valid_store?("redis")
+            assert_equal true, CachedRecord::Cache.valid_store?("memcached")
+            assert_equal true, CachedRecord::Cache.valid_store?(:redis)
+            assert_equal true, CachedRecord::Cache.valid_store?(:memcached)
+            assert_equal false, CachedRecord::Cache.valid_store?("foo")
+            assert_equal false, CachedRecord::Cache.valid_store?(:foo)
+          end
+        end
+        describe ".store" do
+          describe "with as_cache[:store]" do
+            describe "when valid" do
+              it "returns the specified cache client" do
+                klass = mock
+                klass.expects(:as_cache).returns({:store => :redis})
+                CachedRecord::Cache.expects(:send).with(:redis)
+                CachedRecord::Cache.store(klass)
+              end
+            end
+            describe "when invalid" do
+              it "returns the specified cache client" do
+                klass = mock
+                klass.expects(:as_cache).returns({:store => :foo})
+                assert_raises CachedRecord::Cache::Error do
+                  CachedRecord::Cache.store(klass)
+                end
+              end
+            end
+          end
+          describe "without as_cache[:store]" do
+            before do
+              @klass = mock
+              @klass.stubs(:as_cache).returns({})
+            end
+            describe "with zero cache stores" do
+              it "raises an error" do
+                CachedRecord::Cache.instance_variable_set :@stores, {}
+                assert_raises CachedRecord::Cache::Error do
+                  CachedRecord::Cache.store(@klass)
+                end
+              end
+            end
+            describe "with one cache store" do
+              it "returns the cache store" do
+                CachedRecord::Cache.instance_variable_set :@stores, {:memcached => mock}
+                CachedRecord::Cache.store(@klass)
+              end
+            end
+            describe "with multiple cache store" do
+              it "raises an error" do
+                CachedRecord::Cache.instance_variable_set :@stores, {:memcached => mock, :redis => mock}
+                assert_raises CachedRecord::Cache::Error do
+                  CachedRecord::Cache.store(@klass)
+                end
+              end
+            end
+          end
+        end
+        describe ".cache" do
+          it "returns a Hash" do
+            assert_equal({Dalli::Client => {}, Redis => {}}, CachedRecord::Cache.cache)
+          end
+        end
+        describe ".clear!" do
+          it "returns a Hash" do
+            CachedRecord::Cache.instance_variable_set :@cache, {:foo => :bar}
+            assert_equal({:foo => :bar}, CachedRecord::Cache.cache)
+
+            CachedRecord::Cache.clear!
+            assert_nil CachedRecord::Cache.instance_variable_get(:@cache)
+
+            assert_equal({Dalli::Client => {}, Redis => {}}, CachedRecord::Cache.cache)
+          end
+        end
+        describe ".get" do
+          before do
+            @klass = mock
+            @klass.stubs(:cache_key).returns("mock.123")
+          end
+          describe "without memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({})
+            end
+            describe "with cache entry" do
+              it "returns a cached instance" do
+                store = mock
+                store.expects(:get).with("mock.123").returns('{"id":123}')
+                CachedRecord::Cache.expects(:store).with(@klass).returns(store)
+
+                cached_instance = mock
+                @klass.expects(:load_cache_json).with({"id" => 123}).returns cached_instance
+
+                assert_equal cached_instance, CachedRecord::Cache.get(@klass, 123)
+              end
+            end
+          end
+          describe "with memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({:store => :redis, :memoize => true})
+            end
+            describe "without cache entry" do
+              it "returns nil" do
+                store = mock
+                store.expects(:get).with("mock.123").returns(nil)
+                CachedRecord::Cache.expects(:store).with(@klass).returns(store)
+                assert_equal nil, CachedRecord::Cache.get(@klass, 123)
+              end
+            end
+            describe "with cache entry" do
+              before do
+                @store = mock
+                @store.stubs(:get).with("mock.123").returns('{"id":123,"foo":"b@r"}@123456')
+                @store.stubs(:class).returns(Redis)
+                CachedRecord::Cache.stubs(:store).with(@klass).returns(@store)
+              end
+              describe "without memoized instance" do
+                it "returns a memoized instance" do
+                  hash = mock
+                  instance = mock
+
+                  CachedRecord::Cache.expects(:cache).returns(Redis => hash)
+                  hash.expects(:[]).with("mock.123").returns(nil)
+                  hash.expects(:[]=).with("mock.123", :instance => instance, :epoch_time => 123456)
+                  @klass.expects(:load_cache_json).with({"id" => 123,"foo" => "b@r"}).returns instance
+
+                  assert_equal instance, CachedRecord::Cache.get(@klass, 123)
+
+                  cache = {Redis => {"mock.123" => {:instance => instance, :epoch_time => 123456}}}
+                  CachedRecord::Cache.expects(:cache).returns(cache)
+                  @klass.expects(:load_cache_json).never
+
+                  assert_equal instance, CachedRecord::Cache.get(@klass, 123)
+                end
+              end
+              describe "with memoized instance" do
+                describe "outdated instance" do
+                  it "returns a new memoized instance" do
+                    hash = mock
+                    outdated_instance = mock
+                    instance = mock
+
+                    CachedRecord::Cache.expects(:cache).returns(Redis => hash)
+                    hash.expects(:[]).with("mock.123").returns({:instance => outdated_instance, :epoch_time => 12345})
+                    hash.expects(:[]=).with("mock.123", :instance => instance, :epoch_time => 123456)
+                    @klass.expects(:load_cache_json).with({"id" => 123,"foo" => "b@r"}).returns instance
+
+                    assert_equal instance, CachedRecord::Cache.get(@klass, 123)
+
+                    cache = {Redis => {"mock.123" => {:instance => instance, :epoch_time => 123456}}}
+                    CachedRecord::Cache.expects(:cache).returns(cache)
+                    @klass.expects(:load_cache_json).never
+
+                    assert_equal instance, CachedRecord::Cache.get(@klass, 123)
+                  end
+                end
+                describe "uptodate instance" do
+                  it "returns the memoized instance" do
+                    hash = mock
+                    instance = mock
+
+                    CachedRecord::Cache.expects(:cache).returns(Redis => hash)
+                    hash.expects(:[]).with("mock.123").returns({:instance => instance, :epoch_time => 123456})
+                    @klass.expects(:load_cache_json).never
+
+                    assert_equal instance, CachedRecord::Cache.get(@klass, 123)
+                  end
+                end
+              end
+            end
+          end
+        end
+        describe ".set" do
+          before do
+            id = 123
+
+            @klass = mock
+            @klass.stubs(:cache_key).with(id).returns("mock.123")
+
+            @instance = mock
+            @instance.stubs(:id).returns(id)
+            @instance.stubs(:class).returns(@klass)
+            @instance.stubs(:to_cache_json).returns('{"id":123}')
+
+            @store = mock
+            CachedRecord::Cache.stubs(:store).returns(@store)
+          end
+          describe "without memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({})
+            end
+            it "stores cache JSON" do
+              @store.expects(:set).with("mock.123", '{"id":123}', nil)
+              CachedRecord::Cache.set @instance
+            end
+          end
+          describe "with memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({:memoize => true})
+            end
+            it "stores cache JSON" do
+              Time.any_instance.expects(:to_i).returns(123456789)
+              @store.expects(:set).with("mock.123", '{"id":123}@123456789', nil)
+              CachedRecord::Cache.set @instance
+            end
+          end
+        end
+        describe ".expire" do
+          before do
+            id = 123
+
+            @klass = mock
+            @klass.stubs(:cache_key).with(id).returns("mock.123")
+
+            @instance = mock
+            @instance.stubs(:id).returns(id)
+            @instance.stubs(:class).returns(@klass)
+
+            @store = mock
+            CachedRecord::Cache.stubs(:store).returns(@store)
+          end
+          describe "without memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({:store => :redis})
+            end
+            it "deletes key from cache store" do
+              @store.expects(:delete).with("mock.123")
+              CachedRecord::Cache.expire @instance
+            end
+          end
+          describe "with memoization" do
+            before do
+              @klass.stubs(:as_cache).returns({:store => :redis, :memoize => true})
+            end
+            it "deletes key from cache store and memoized cache" do
+              hash = mock
+              hash.expects(:delete).with("mock.123")
+              @store.expects(:delete).with("mock.123")
+              CachedRecord::Cache.expects(:cache).returns @store.class => hash
+              CachedRecord::Cache.expire @instance
+            end
+          end
+        end
+        describe ".memoized" do
+          describe "without memoization" do
+            it "returns nil" do
+              klass = mock
+              klass.expects(:as_cache).returns({})
+              instance = mock
+
+              CachedRecord::Cache.expects(:cache).never
+              assert_equal instance, CachedRecord::Cache.memoized(klass, 123, 123456789) { instance }
+            end
+          end
+          describe "with memoization" do
+            before do
+              @klass = mock
+              @klass.stubs(:as_cache).returns({:store => :redis, :memoize => true})
+              @klass.stubs(:cache_key).returns("mock.123")
+            end
+            describe "empty cache hash" do
+              it "returns nil" do
+                hash = mock
+                hash.expects(:[]).with("mock.123")
+                CachedRecord::Cache.expects(:cache).returns Redis => hash
+                assert_nil CachedRecord::Cache.memoized(@klass, 123, 123456789) {}
+              end
+            end
+            describe "matching cache hash entry" do
+              before do
+                @instance = mock
+              end
+              describe "non matching epoch time" do
+                it "returns nil" do
+                  hash = mock
+                  hash.expects(:[]).with("mock.123").returns :instance => mock, :epoch_time => 123456789
+                  hash.expects(:[]=).with("mock.123", {:instance => @instance, :epoch_time => 987654321})
+
+                  CachedRecord::Cache.expects(:cache).returns Redis => hash
+                  assert_equal @instance, CachedRecord::Cache.memoized(@klass, 123, 987654321) { @instance }
+                end
+              end
+              describe "matching epoch time" do
+                it "returns memoized instance" do
+                  hash = mock
+                  hash.expects(:[]).with("mock.123").returns :instance => @instance, :epoch_time => 123456789
+
+                  CachedRecord::Cache.expects(:cache).returns Redis => hash
+                  assert_equal @instance, CachedRecord::Cache.memoized(@klass, 123, 123456789) { mock }
+                end
+              end
+            end
+          end
+        end
+        describe ".split_cache_string" do
+          it "returns an array containing a JSON string and an optional epoch time integer" do
+            assert_equal ["", nil], CachedRecord::Cache.send(:split_cache_string, "")
+            assert_equal ['{"id":123,"foo":"b@r"}', nil], CachedRecord::Cache.send(:split_cache_string, '{"id":123,"foo":"b@r"}')
+            assert_equal ['{"id":123,"foo":"b@r"}', 123456789], CachedRecord::Cache.send(:split_cache_string, '{"id":123,"foo":"b@r"}@123456789')
+          end
+        end
+      end
+    end
+
+  end
+end

data/test/unit/test_cached_record.rb

@@ -0,0 +1,34 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestCachedRecord < MiniTest::Test
+
+    describe CachedRecord do
+      it "has the current version" do
+        version = "0.1.0"
+        assert_equal version, CachedRecord::VERSION
+        assert File.read(path "CHANGELOG.rdoc").include?("Version #{version}")
+        assert File.read(path "VERSION").include?(version)
+      end
+
+      describe ".setup" do
+        it "sets up ActiveRecord, DataMapper and Cache" do
+          CachedRecord::Cache.expects(:redis).with(:host => "127.0.0.1")
+          CachedRecord::Cache.expects(:memcached).with(:host => "0.0.0.0")
+          CachedRecord::ORM::ActiveRecord.expects(:setup)
+          CachedRecord::ORM::DataMapper.expects(:setup)
+          CachedRecord.setup :redis => {:host => "127.0.0.1"}, :memcached => {:host => "0.0.0.0"}
+        end
+
+        it "accepts an array of cache stores" do
+          CachedRecord::Cache.expects(:redis)
+          CachedRecord::Cache.expects(:memcached)
+          CachedRecord::ORM::ActiveRecord.expects(:setup)
+          CachedRecord::ORM::DataMapper.expects(:setup)
+          CachedRecord.setup :redis, :memcached
+        end
+      end
+    end
+
+  end
+end

data/test/unit/test_orm.rb

@@ -0,0 +1,193 @@
+require File.expand_path("../../test_helper", __FILE__)
+
+module Unit
+  class TestORM < MiniTest::Test
+
+    class A
+      include CachedRecord::ORM
+      as_cache :redis, "only" => [:title], :include => [:b], :memoize => [:sequence]
+      def id; end
+    end
+
+    class B
+      include CachedRecord::ORM
+      as_cache :redis, "only" => [:title], :include => [:b], "memoize" => {"calculate" => :@array}
+    end
+
+    class C
+      include CachedRecord::ORM
+      as_cache :redis, :only => [:title], "include" => [:b], :memoize => [:sequence, {:calculate => "@array"}]
+    end
+
+    class D
+      include CachedRecord::ORM
+      as_cache :redis, :only => [:title], :include_root => true
+    end
+
+    describe CachedRecord::ORM do
+      describe "when extended within a class" do
+
+        describe "classes" do
+          it "validates and parses 'as cache json options'" do
+            assert_raises ArgumentError do
+              A.as_cache :foonly => []
+            end
+            assert_raises ArgumentError do
+              A.as_cache :only => :foo
+            end
+            assert_raises ArgumentError do
+              A.as_cache :include => :foo
+            end
+            assert_raises ArgumentError do
+              A.as_cache :memoize => :foo
+            end
+            assert_raises ArgumentError do
+              A.as_cache :include_root => :foo
+            end
+          end
+          it "stores its cache options" do
+            assert_equal({
+              :store => :redis,
+              :as_json => {
+                :only => [:title],
+                :include => [:b],
+                :memoize => {:sequence => :@sequence}
+              }
+            }, A.as_cache)
+            assert_equal({
+              :store => :redis,
+              :as_json => {
+                :only => [:title],
+                :include => [:b],
+                :memoize => {:calculate => :@array}
+              }
+            }, B.as_cache)
+            assert_equal({
+              :store => :redis,
+              :as_json => {
+                :only => [:title],
+                :include => [:b],
+                :memoize => {:sequence => :@sequence, :calculate => :@array}
+              }
+            }, C.as_cache)
+            assert_equal({
+              :store => :redis,
+              :as_json => {
+                :only => [:title],
+                :include_root => true
+              }
+            }, D.as_cache)
+          end
+          it "stores whether it should memoize instances" do
+            options = {}
+            A.expects(:as_cache).with(:foo => :bar).returns(options)
+            A.as_memoized_cache :foo => :bar
+            assert_equal options, {:memoize => true}
+          end
+          it "memoizes its cache options" do
+            options = A.as_cache
+            assert_equal options.object_id, A.as_cache.object_id
+          end
+          it "returns cache keys" do
+            assert_equal "unit.test_orm.a.123", A.cache_key(123)
+          end
+          it "returns the cache root" do
+            assert_equal :a, A.cache_root
+          end
+          it "requires an implemented `uncached` method" do
+            assert_raises NotImplementedError do
+              A.uncached 1
+            end
+          end
+          it "requires an implemented `set_cached_association` method" do
+            assert_raises NotImplementedError do
+              A.send :set_cached_association, :a, :b, :c
+            end
+          end
+        end
+
+        describe "instances" do
+          it "requires an implemented `cache_attributes` method" do
+            assert_raises NotImplementedError do
+              A.new.cache_attributes
+            end
+          end
+          it "requires an implemented `cache_foreign_keys` method" do
+            assert_raises NotImplementedError do
+              A.new.cache_foreign_keys
+            end
+          end
+          it "knows its as cache JSON options" do
+            assert_equal({
+              :only => [:title],
+              :include => [:b],
+              :memoize => {:sequence => :@sequence}
+            }, A.new.send(:cache_json_options))
+            assert_equal({
+              :only => [:title],
+              :include => [:b],
+              :memoize => {:calculate => :@array}
+            }, B.new.send(:cache_json_options))
+            assert_equal({
+              :only => [:title],
+              :include => [:b],
+              :memoize => {:sequence => :@sequence, :calculate => :@array}
+            }, C.new.send(:cache_json_options))
+            assert_equal({
+              :only => [:title],
+              :include_root => true
+            }, D.new.send(:cache_json_options))
+          end
+          it "returns a cache JSON string" do
+            hash = mock
+            hash.expects(:to_json)
+            a = A.new
+            a.expects(:as_cache_json).returns(hash)
+            a.to_cache_json
+          end
+        end
+
+        describe ".cached" do
+          describe "when not having a cache entry" do
+            it "returns an uncached instance and stores its cache JSON in the cache store" do
+              uncached_instance = A.new
+              uncached_instance.expects(:to_cache_json).returns({})
+
+              A.stubs(:as_cache).returns({:store => :redis, :as_json => {}})
+              A.expects(:uncached).with(123).returns uncached_instance
+              A.expects(:new).returns uncached_instance
+
+              assert_equal uncached_instance, A.cached(123)
+            end
+          end
+          describe "when having a cache entry" do
+            it "returns a cached instance" do
+              cached_instance = mock
+              CachedRecord::Cache.expects(:get).with(A, 123).returns cached_instance
+              assert_equal cached_instance, A.cached(123)
+            end
+          end
+        end
+
+        describe "#cache" do
+          it "delegates to class.cached" do
+            id, instance = 2, A.new
+            instance.expects(:id).returns(id)
+            A.expects(:cached).with(id)
+            assert instance.cache
+          end
+        end
+
+        describe "#expire" do
+          it "delegates to CachedRecord::Cache.expire" do
+            instance = A.new
+            CachedRecord::Cache.expects(:expire).with(instance)
+            assert instance.expire
+          end
+        end
+
+      end
+    end
+
+  end
+end