cachely 0.0.1 → 0.0.2

data/test/models/dummy_model.rb

@@ -1,3 +1,7 @@
 class DummyModel < ActiveRecord::Base
-  attr_accessible :attr1, :attr2
+  attr_accessible :attr_1, :attr_2
+  
+  def instance_fixnum
+    rand(500)
+  end
 end

data/test/unit/base_test.rb

@@ -12,7 +12,9 @@ class BaseTest < ActiveSupport::TestCase
     database_config ||= YAML.load(File.open(File.dirname(__FILE__)+'/../../config/database.yml', 'r'))
     ActiveRecord::Base.configurations = database_config
     ActiveRecord::Base.establish_connection("test")
-
+    conf =  YAML.load(File.read('./config/redis.yml'))
+    Cachely::Mechanics.connect(conf["test"])
+    Cachely::Mechanics.flush_all_keys
     DummyModel.destroy_all
   end
 end

data/test/unit/cachely_test.rb

@@ -1,7 +1,146 @@
 require_relative 'base_test.rb'
-
+#This test level is for functionality that occurs at the cachely.rb level. Things that interact
+#With the model.
 class CachelyTest < BaseTest
-  test "caches output of integer instance method" do
-    assert_equal(DummyClass.new.test_function_num, DummyClass.new.test_function_num)   
+  #later test: having defaults in parameters.
+  test "caches output of instance and class methods primitive" do
+    ["instance","class"].each do |preset|
+      [
+        "fixnum", 
+        "float", 
+        "string", 
+        "symbol", 
+        "nilclass", 
+        "trueclass", 
+        "falseclass"
+      ].each do |type|
+        obj = (preset == "class" ? DummyClass : DummyClass.new)
+        assert_equal(obj.send(preset+ "_" + type), obj.send(preset + "_" + type))  
+        assert_equal(obj.send(preset+ "_" + type+"_one",3), obj.send(preset+ "_" + type + "_one",3))   
+        assert_equal(obj.send(preset+ "_" + type+"_two",3,4), obj.send(preset+ "_" + type + "_two",3,4))   
+        if(!["nilclass", "trueclass", "falseclass"].include?(type)) #always will be nil/false/true the way we set up tests.
+          assert_not_equal(obj.send(preset+ "_" + type+"_two",3,5), obj.send(preset+ "_" + type + "_two",3,4))   
+        end
+      end 
+    end
   end
+  
+  test "caches output of instance and class methods orm" do
+    ["instance","class"].each do |preset|
+      obj = preset == "class" ? DummyClass : DummyClass.new
+      assert_equal(obj.send(preset+ "_orm").id, obj.send(preset + "_orm").id)  
+      assert_equal(obj.send(preset+ "_orm_one",3).id, obj.send(preset+ "_orm_one" ,3).id)   
+      assert_equal(obj.send(preset+ "_orm_two",3,4).id, obj.send(preset+ "_orm_two",3,4).id)   
+      assert_not_equal(obj.send(preset+ "_orm_two",3,5).id, obj.send(preset+ "_orm_two",3,4).id)
+    end
+  end
+  
+  test "caches output of instance and class methods hash" do
+    ["instance","class"].each do |preset|
+      obj = preset == "class" ? DummyClass : DummyClass.new
+      get_back = obj.send(preset+ "_hash")
+      get_back_2 = obj.send(preset+ "_hash")
+      assert_equal(get_back.keys.size, get_back_2.keys.size)
+      assert_equal(get_back[:foo], get_back_2[:foo])
+      
+      get_back = obj.send(preset+ "_hash_one",3)
+      get_back_2 = obj.send(preset+ "_hash_one",3)
+      assert_equal(get_back.keys.size, get_back_2.keys.size)
+      assert_equal(get_back[:foo], get_back_2[:foo])
+      
+      get_back = obj.send(preset+ "_hash_two",3,4)
+      get_back_2 = obj.send(preset+ "_hash_two",3,4)
+      assert_equal(get_back.keys.size, get_back_2.keys.size)
+      assert_equal(get_back[:foo], get_back_2[:foo])
+      
+      get_back = obj.send(preset+ "_hash_two",3,5)
+      get_back_2 = obj.send(preset+ "_hash_two",3,4)
+      assert_equal(get_back.keys.size, get_back_2.keys.size)
+      assert_not_equal(get_back[:foo], get_back_2[:foo])
+    end
+  end
+  
+  test "caches output of instance and class methods array" do
+    ["instance","class"].each do |preset|
+      obj = preset == "class" ? DummyClass : DummyClass.new
+      get_back = obj.send(preset+ "_array")
+      get_back_2 = obj.send(preset+ "_array")
+      assert_equal(0, get_back <=> get_back_2)
+      
+      get_back = obj.send(preset+ "_array_one",3)
+      get_back_2 = obj.send(preset+ "_array_one",3)
+      assert_equal(0, get_back <=> get_back_2)
+      
+      get_back = obj.send(preset+ "_array_two",3,4)
+      get_back_2 = obj.send(preset+ "_array_two",3,4)
+      assert_equal(0, get_back <=> get_back_2)
+      
+      get_back = obj.send(preset+ "_array_two",3,5)
+      get_back_2 = obj.send(preset+ "_array_two",3,4)
+      assert_not_equal(0, get_back <=> get_back_2)
+    end
+  end
+  
+  test "caches output of instance and class methods to_json" do
+    ["instance"].each do |preset|
+      obj = preset == "class" ? DummyClass : DummyClass.new
+      get_back = obj.send(preset+ "_to_json")
+      get_back_2 = obj.send(preset+ "_to_json")
+      assert_equal(get_back.random_no, get_back_2.random_no)
+      
+      get_back = obj.send(preset+ "_to_json_one",3)
+      get_back_2 = obj.send(preset+ "_to_json_one",3)
+      assert_equal(get_back.random_no, get_back_2.random_no)
+      
+      get_back = obj.send(preset+ "_to_json_two",3,4)
+      get_back_2 = obj.send(preset+ "_to_json_two",3,4)
+      assert_equal(get_back.random_no, get_back_2.random_no)
+      
+      get_back = obj.send(preset+ "_to_json_two",3,5)
+      get_back_2 = obj.send(preset+ "_to_json_two",3,4)
+      assert_equal(get_back.random_no, get_back_2.random_no)
+    end
+  end
+  
+  test "updated object in argument triggers cache refill" do
+    #an updated object means logic inside might react differently. SO we need to not get it.
+    ["instance","class"].each do |preset|
+      obj = preset == "class" ? DummyClass : DummyClass.new
+        d = DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+        get_back = obj.send(preset+"_fixnum_one", d)
+        d.attr_1 +=1
+        old_time = d.updated_at
+        d.save!
+        assert_not_equal(old_time, d.updated_at) #just making sure it overwrote it correctly.
+        
+        get_back_2 = obj.send(preset+"_fixnum_one", d)
+        assert_not_equal(get_back, get_back_2) #because orm changed.
+    end
+  end
+  
+  test "instance method called on two diff objects knows its different" do
+    obj_1 = DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+    obj_2 = DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+    assert_not_equal(obj_1.instance_fixnum, obj_2.instance_fixnum)
+  end
+  
+  test "class method gets cached while normal one does not" do
+    obj = DummyClass.new
+    klazz = DummyClass
+    assert_not_equal(obj.instance_only_cache, klazz.instance_only_cache)
+  end
+  
+  test "diff between class and obj method" do
+    obj = DummyClass.new
+    klazz = DummyClass
+    assert_not_equal(obj.class_diff, klazz.class_diff)
+  end
+  
+  test "cache expires" do
+    obj = DummyClass.new
+    old = obj.cache_expiry
+    sleep(3)
+    assert_not_equal(old, obj.cache_expiry)
+  end
+  
 end

data/test/unit/conversions_test.rb

@@ -0,0 +1,68 @@
+require_relative 'base_test.rb'
+#Only do conversions testing here. Test recursivity.
+class ConversionsTest < BaseTest
+  test "hash conversion" do
+    str = Cachely::Mechanics.map_param_to_s({:foo => "bar", :baz => { "nada" => :pink }})
+    reformed = Cachely::Mechanics.map_s_to_param(str)
+    assert_equal("bar", reformed[:foo])
+    assert(reformed[:baz].is_a?(Hash))
+    internal = reformed[:baz]
+    assert_equal(:pink, internal["nada"])
+    assert_equal(2, reformed.keys.size)
+    assert_equal(1, internal.keys.size)
+  end
+  
+  test "hash conversion with an array subkey" do
+    str = Cachely::Mechanics.map_param_to_s({
+      :method => :foo,
+      :args => [3,4]
+    })
+    assert_equal("{\"Symbol:method\":\"Symbol:foo\",\"Symbol:args\":\"[\\\"Fixnum:3\\\",\\\"Fixnum:4\\\"]\"}",str)
+    reformed = Cachely::Mechanics.map_s_to_param(str)
+    assert_equal(2, reformed.keys.size)
+    assert_equal(:foo, reformed[:method])
+    assert_equal(0, [3,4] <=> reformed[:args])
+  end
+  
+  test "array conversion" do
+    str = Cachely::Mechanics.map_param_to_s([1,2,["3","4"]])
+    reformed = Cachely::Mechanics.map_s_to_param(str)
+    assert_equal(0,[1,2,["3", "4"]] <=> reformed)
+  end
+  
+  test "to_json obj conversion" do
+    d = DummyClass.new
+    d.random_no = rand(500)
+    str = Cachely::Mechanics.map_param_to_s(d)
+    reformed = Cachely::Mechanics.map_s_to_param(str)
+    assert_equal(d.random_no, reformed.random_no)
+  end
+  
+  test "orm conversion" do
+    d = DummyModel.create!(:attr_1 => rand(500), :attr_2 => rand(500))
+    str = Cachely::Mechanics.map_param_to_s(d)
+    reformed = Cachely::Mechanics.map_s_to_param(str)
+    assert_equal(d.attr_1, reformed.attr_1)
+    assert_equal(d.attr_2, reformed.attr_2)
+    assert_equal(d.id, reformed.id)
+  end
+  
+  test "primitives conversion" do
+    assert_equal("TrueClass:true", Cachely::Mechanics.map_param_to_s(true))
+    assert_equal("FalseClass:false", Cachely::Mechanics.map_param_to_s(false))
+    assert_equal("Fixnum:1", Cachely::Mechanics.map_param_to_s(1))
+    assert_equal("Float:1.1", Cachely::Mechanics.map_param_to_s(1.1))
+    assert_equal("String:1", Cachely::Mechanics.map_param_to_s("1"))   
+    assert_equal("NilClass:nil", Cachely::Mechanics.map_param_to_s(nil))    
+    assert_equal("Symbol:shit", Cachely::Mechanics.map_param_to_s(:shit))    
+    assert_equal(true, Cachely::Mechanics.map_s_to_param("TrueClass:true"))
+    assert_equal(false, Cachely::Mechanics.map_s_to_param("FalseClass:false"))
+    assert_equal(1, Cachely::Mechanics.map_s_to_param("Fixnum:1"))
+    assert_equal(1.1, Cachely::Mechanics.map_s_to_param("Float:1.1"))
+    assert_equal("1", Cachely::Mechanics.map_s_to_param("String:1"))
+    assert_equal("1:2", Cachely::Mechanics.map_s_to_param("String:1:2"))
+    assert_equal(:shit, Cachely::Mechanics.map_s_to_param("Symbol:shit"))
+    assert_equal(nil, Cachely::Mechanics.map_s_to_param("NilClass:nil"))
+    
+  end
+end

data/test/unit/mechanics_test.rb

@@ -0,0 +1,41 @@
+require_relative 'base_test.rb'
+
+#This is for mechanics.rb test that don't have to do with conversions, which are complex enough to 
+#have their own file. Test getting/storing, stuff like that.
+class MechanicsTest < BaseTest
+  test "get/store array" do
+    Cachely::Mechanics.store(DummyClass,:foo, [1,2,3], nil, [3,4])
+    assert_equal(0, [1,2,3] <=> Cachely::Mechanics.get(DummyClass,:foo, [3,4]).first)
+  end
+  
+  test "get/store hash" do
+    Cachely::Mechanics.store(DummyClass,:foo, {:bar => "baz"}, nil, [3,4])
+    respawned = Cachely::Mechanics.get(DummyClass,:foo, [3,4]).first
+    assert_equal(1, respawned.keys.size)
+    assert_equal("baz", respawned[:bar])
+  end
+  
+  test "get/store orm" do
+    d = DummyModel.create!(:attr_1 => 1, :attr_2 => 3)
+    Cachely::Mechanics.store(DummyClass,:foo, d,nil,[3,4])
+    respawned = Cachely::Mechanics.get(DummyClass,:foo, [3,4]).first
+    assert_equal(d.id, respawned.id)
+    assert_equal(d.attr_1, respawned.attr_1)
+    assert_equal(d.attr_2, respawned.attr_2)
+  end
+  
+  test "get/store to_json" do
+    d = DummyClass.new
+    Cachely::Mechanics.store(DummyClass,:foo, d,nil, [3,4])
+    respawned = Cachely::Mechanics.get(DummyClass,:foo, [3,4]).first
+    assert_equal(d.random_no, respawned.random_no)
+  end
+  
+  test "get/store primitive" do
+    [3, "3", true, false, nil, 3.5, :stuff].each do |result|
+      Cachely::Mechanics.store(DummyClass,:foo, result, nil, [3,4])
+      respawned = Cachely::Mechanics.get(DummyClass,:foo, [3,4]).first
+      assert_equal(result, respawned)
+    end
+  end
+end

metadata

@@ -1,34 +1,71 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: cachely
-version: !ruby/object:Gem::Version
-  version: 0.0.1
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.2
 platform: ruby
-authors:
+authors: 
 - Jordan Prince
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-01 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: em-hiredis
-  requirement: &15818540 !ruby/object:Gem::Requirement
+
+date: 2013-03-04 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redis
+  requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *15818540
-description: Coming soon.
-email:
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hiredis
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.4.5
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: em-synchrony
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: json
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  prerelease: false
+  version_requirements: *id004
+description: Transparently cache the results of methods using redis.
+email: 
 - jordanmprince@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files:
+
+files: 
 - .gitignore
 - Gemfile
 - LICENSE
@@ -36,40 +73,54 @@ files:
 - Rakefile
 - cachely.gemspec
 - config/database.yml
+- config/redis.yml
 - db/migrate/001_create_dummy_model.rb
 - lib/cachely.rb
+- lib/cachely/mechanics.rb
 - lib/cachely/version.rb
 - test/models/dummy_class.rb
 - test/models/dummy_model.rb
 - test/unit/base_test.rb
 - test/unit/cachely_test.rb
-homepage: ''
+- test/unit/conversions_test.rb
+- test/unit/mechanics_test.rb
+homepage: ""
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
+
+require_paths: 
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -39538212363365102
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -39538212363365102
+      segments: 
+      - 0
+      version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.11
+rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Use em-redis to transparently cache results from your class methods. Eventmachine
-  compatible out of the box!
-test_files:
+summary: Transparently cache the results of methods using redis.
+test_files: 
 - test/models/dummy_class.rb
 - test/models/dummy_model.rb
 - test/unit/base_test.rb
 - test/unit/cachely_test.rb
+- test/unit/conversions_test.rb
+- test/unit/mechanics_test.rb