sequel-unicache 0.9.0

data/spec/global_configuration_spec.rb

@@ -0,0 +1,56 @@
+describe Sequel::Unicache::GlobalConfiguration do
+  it 'should be true' do
+    expect(Sequel::Unicache.config).to be_kind_of Sequel::Unicache::GlobalConfiguration
+  end
+
+  it 'can configure for unicache' do
+    logger = Logger.new(STDERR)
+
+    Sequel::Unicache.configure cache: memcache,
+                               ttl: 30,
+                               logger: logger
+
+    expect(Sequel::Unicache.config.cache).to be memcache
+    expect(Sequel::Unicache.config.ttl).to be 30
+    expect(Sequel::Unicache.config.enabled).to be true
+    expect(Sequel::Unicache.config.logger).to be logger
+
+    serialize_proc = ->(model, opts) { Marshal.dump model }
+    deserialize_proc = ->(cache, opts) { Marshal.load cache }
+    key_proc = ->(hash, opts) { "id/#{hash[:id]}" }
+
+    Sequel::Unicache.config.serialize = serialize_proc
+    Sequel::Unicache.config.deserialize = deserialize_proc
+    Sequel::Unicache.config.key = key_proc
+
+    expect(Sequel::Unicache.config.serialize).to be serialize_proc
+    expect(Sequel::Unicache.config.deserialize).to be deserialize_proc
+    expect(Sequel::Unicache.config.key).to be key_proc
+
+    expect(Sequel::Unicache.config.to_h).to eq cache: memcache,
+                                               ttl: 30,
+                                               enabled: true,
+                                               logger: logger,
+                                               serialize: serialize_proc,
+                                               deserialize: deserialize_proc,
+                                               key: key_proc
+  end
+
+  it 'can enable & disable unicache feature' do
+    Sequel::Unicache.disable
+    expect(Sequel::Unicache.enabled?).to be false
+    Sequel::Unicache.enable
+    expect(Sequel::Unicache.enabled?).to be true
+  end
+
+  it 'can suspend & unsuspend read-through' do
+    Sequel::Unicache.suspend_unicache
+    expect(Sequel::Unicache.unicache_suspended?).to be true
+    Sequel::Unicache.unsuspend_unicache
+    expect(Sequel::Unicache.unicache_suspended?).to be false
+    Sequel::Unicache.suspend_unicache do
+      expect(Sequel::Unicache.unicache_suspended?).to be true
+    end
+    expect(Sequel::Unicache.unicache_suspended?).to be false
+  end
+end

data/spec/log_spec.rb

@@ -0,0 +1,28 @@
+describe Sequel::Unicache::Logger do
+  let!(:logger) { Logger.new STDOUT }
+  let!(:user_id) { User.first.id }
+  before :each do
+    Sequel::Unicache.configure cache: memcache, logger: logger
+  end
+
+  context 'read through' do
+    it 'should log down and ignore exception if failed to serialize' do
+      User.instance_exec { unicache :id, serialize: ->(values, _) { raise 'test' } }
+      expect(logger).to receive(:error).at_least(:once)
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+  end
+
+  context 'expire' do
+    it 'should log down, ignore exception when failed to expire during model destroy' do
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      User.instance_exec { unicache :id, key: ->(values, _) { raise 'test' } }
+      expect(logger).to receive(:fatal).at_least(:once)
+      user.destroy
+    end
+  end
+end

data/spec/memcache.yml.example

@@ -0,0 +1,8 @@
+servers:
+    - host: localhost
+      port: 11211
+options:
+    namespace: sequel
+    compress: true
+    threadsafe: true
+    failover: true

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+require 'bundler'
+
+begin
+  ENV['BUNDLE_GEMFILE'] = File.expand_path('../Gemfile', __dir__)
+  Bundler.setup
+rescue Bundler::GemNotFound
+  abort "Bundler couldn't find some gems.\n" \
+        'Did you run `bundle install`?'
+end
+
+require 'erb'
+require 'logger'
+require 'json'
+require 'yaml'
+
+require 'sequel/unicache'
+require 'active_support/core_ext/hash/keys'
+require 'dalli'
+require 'pry'
+
+module Helpers
+  def memcache
+    @cache ||= begin
+      memcache_config = YAML.load(ERB.new(File.read(File.expand_path('memcache.yml', __dir__))).result)
+
+      hosts = memcache_config['servers'].map {|server| "#{server['host']}:#{server['port']}" }
+      opts = memcache_config['options'] || {}
+
+      client = Dalli::Client.new hosts, opts.symbolize_keys
+      client.alive!
+      client
+    rescue Dalli::RingError
+      abort "Memcache Server is unavailable."
+    rescue Errno::ENOENT
+      abort "You must configure memcache in spec/memcache.yml before the testing.\n" \
+                  "Copy from spec/memcache.yml.example then modify base on it will be recommended."
+    end
+  end
+
+  def initialize_models
+    user_class = Class.new Sequel::Model
+    user_class.set_dataset database[:users]
+    user_class.many_to_one :manager, class: :User
+    Object.send :const_set, :User, user_class
+  end
+
+  def clear_models
+    Object.send :remove_const, :User
+  end
+
+  def database
+    @database ||= begin
+      db = Sequel.sqlite
+      db.run <<-SQL
+        CREATE TABLE users(id INTEGER PRIMARY KEY AUTOINCREMENT, manager_id INTEGER,
+                           username VARCHAR NOT NULL, password VARCHAR,
+                           company_name VARCHAR NOT NULL, department VARCHAR NOT NULL,
+                           employee_id INTEGER NOT NULL, created_at DEFAULT CURRENT_TIMESTAMP,
+                           FOREIGN KEY(manager_id) REFERENCES users(id));
+        CREATE UNIQUE INDEX uniq_username ON users(username);
+        CREATE UNIQUE INDEX uniq_employee ON users(company_name, department, employee_id);
+      SQL
+      user_id = db[:users].insert username: 'bachue@gmail.com', password: 'bachue',
+                                  company_name: 'EMC', department: 'Mozy', employee_id: 12345
+      boss_id = db[:users].insert username: 'gimi@emc.com', password: 'gimi',
+                                  company_name: 'EMC', department: 'Mozy', employee_id: 10000
+      db[:users].where(id: user_id).update manager_id: boss_id
+      db
+    end
+  end
+
+  def reset_database
+    return unless @database
+    @database = nil
+  end
+
+  def reset_global_configuration
+    Sequel::Unicache.instance_variable_set :@config, Sequel::Unicache::GlobalConfiguration.new
+    Sequel::Unicache.enable
+  end
+end
+
+RSpec.configure do |config|
+  config.include Helpers
+
+  config.before :each do
+    memcache.flush_all
+    initialize_models
+  end
+
+  config.after :each do
+    reset_database
+    clear_models
+    reset_global_configuration
+  end
+end

data/spec/write_spec.rb

@@ -0,0 +1,277 @@
+describe Sequel::Unicache::Write do
+  let!(:user_id) { User.first.id }
+
+  before :each do
+    Sequel::Unicache.configure cache: memcache
+  end
+
+  context 'read through' do
+    it 'should read through cache into memcache' do
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq user.values
+    end
+
+    it 'should serialize model into specified format' do
+      User.instance_exec { unicache :id, serialize: ->(values, _) { values.to_yaml } }
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(YAML.load(cache)).to eq user.values
+    end
+
+    it 'should not read through cache if unicache is not enabled for this key' do
+      User.instance_exec { unicache :id, enabled: false }
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      user = User.find user_id
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not read through cache if unicache is not enabled' do
+      User.instance_exec { unicache :id, enabled: true }
+      Sequel::Unicache.disable
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      user = User.find user_id
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not read through cache if read-through is suspended' do
+      User.instance_exec { unicache :id, enabled: true }
+      user = Sequel::Unicache.suspend_unicache { User[user_id] }
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      user = Sequel::Unicache.suspend_unicache { User.find user_id }
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not read through cache if condition is not permitted' do
+      User.instance_exec { unicache :id, if: ->(model, _) { model.company_name != 'EMC' } }
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should set expiration time as you wish' do
+      User.instance_exec { unicache :id, ttl: 1 }
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      sleep 1
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not read from cache when unicache is disabled' do
+      User[user_id] # cache data
+      Sequel::Unicache.disable
+      User[user_id].set(company_name: 'VMware').save
+      user = User.find user_id
+      expect(user.company_name).to eq 'VMware'
+    end
+
+    it 'should not read from cache when reload' do
+      user = User[user_id]
+      Sequel::Unicache.disable
+      User[user_id].set(company_name: 'VMware').save
+      Sequel::Unicache.enable
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      user.reload
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      expect(user.company_name).to eq 'VMware'
+    end
+  end
+
+  context 'expire when update' do
+    let!(:user) { User[user_id] }
+
+    it 'should expire cache' do
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      user.set(company_name: 'VMware').save
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      user = User[user_id]
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq user.values
+    end
+
+    it 'should not expire cache until transaction is committed' do
+      User.db.transaction auto_savepoint: true do
+        user.set(company_name: 'VMware').save
+        cache = memcache.get "User:id:#{user.id}"
+        expect(cache).not_to be_nil
+      end
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not expire cache if transaction is rollbacked' do
+      origin = user.values.dup
+      User.db.transaction rollback: :always do
+        user.set(company_name: 'VMware').save
+      end
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq origin
+    end
+
+    it 'should not expire cache even if unicache is not enabled for that key' do
+      User.unicache_for(:id).enabled = false
+      origin = user.values.dup
+      user.set(company_name: 'VMware').save
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq origin
+    end
+
+    it 'should not expire cache even if unicache is not enabled' do
+      Sequel::Unicache.disable
+      origin = user.values.dup
+      user.set(company_name: 'VMware').save
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq origin
+    end
+
+    it 'should still expire cache even if read-through is suspended' do
+      Sequel::Unicache.suspend_unicache { user.set(company_name: 'VMware').save }
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should still expire all cache even if model is not completed' do
+      memcache.flush_all # Clear all cache first
+      User.instance_exec { unicache :username, key: ->(values, _) { "User/username/#{values[:username]}" } }
+      user = User[user_id]
+      cache = memcache.get "User/username/bachue@gmail.com"
+      expect(cache).not_to be_nil
+      user = User.select(:id, :company_name)[user_id]
+      user.set(company_name: 'VMware').save
+      cache = memcache.get "User/username/bachue@gmail.com"
+      expect(cache).to be_nil
+    end
+
+    it 'should expire obsolate cache if any value of the unicache key is changed' do
+      User.instance_exec { unicache :username }
+      user = User[user_id]
+      User.db.transaction auto_savepoint: true do
+        user.set(username: 'bachue@emc.com').save
+        user.set(username: 'bachue@vmware.com', company_name: 'VMware').save
+      end
+      cache = memcache.get "User:username:bachue@gmail.com"
+      expect(cache).to be_nil
+    end
+
+    it 'should still get currect value during a transaction' do
+      user = User[user_id]
+      expect(Sequel::Unicache.unicache_suspended?).to be false
+      User.db.transaction auto_savepoint: true do
+        expect(Sequel::Unicache.unicache_suspended?).to be true
+        user.set(username: 'bachue@emc.com').save
+        expect(User[user_id].username).to eq 'bachue@emc.com'
+      end
+      expect(Sequel::Unicache.unicache_suspended?).to be false
+    end
+  end
+
+  context 'expire when delete' do
+    let!(:user) { User[user_id] }
+
+    it 'should expire cache' do
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      user.destroy
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should expire cache' do
+      User.instance_exec { unicache :username }
+      user = User.select(:id).first
+      user.destroy
+      cache = memcache.get "User:username:#{user.username}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not expire cache until transaction is committed' do
+      User.db.transaction auto_savepoint: true do
+        user.destroy
+        cache = memcache.get "User:id:#{user.id}"
+        expect(cache).not_to be_nil
+      end
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+
+    it 'should not expire cache even if unicache is not enabled for that key' do
+      User.unicache_for(:id).enabled = false
+      user.destroy
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq user.values
+    end
+
+    it 'should not expire cache even if unicache is not enabled' do
+      Sequel::Unicache.disable
+      user.destroy
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      expect(Marshal.load(cache)).to eq user.values
+    end
+
+    it 'should still expire cache even if read-through is suspended' do
+      Sequel::Unicache.suspend_unicache { user.destroy }
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+    end
+  end
+
+  context 'expire by #expire_unicache' do
+    let(:user) { User[user_id] }
+
+    before :each do
+      User.instance_exec do
+        unicache :username
+        unicache :company_name, :department, :employee_id
+      end
+    end
+
+    it 'should expire all keys' do
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).not_to be_nil
+      cache = memcache.get "User:username:bachue@gmail.com"
+      expect(cache).not_to be_nil
+      cache = memcache.get "User:company_name:EMC:department:Mozy:employee_id:12345"
+      expect(cache).not_to be_nil
+      user.expire_unicache
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      cache = memcache.get "User:username:bachue@gmail.com"
+      expect(cache).to be_nil
+      cache = memcache.get "User:company_name:EMC:department:Mozy:employee_id:12345"
+      expect(cache).to be_nil
+    end
+
+    it 'should expire all keys even unicache is disabled' do
+      Sequel::Unicache.disable
+      user.expire_unicache
+      cache = memcache.get "User:id:#{user.id}"
+      expect(cache).to be_nil
+      cache = memcache.get "User:username:bachue@gmail.com"
+      expect(cache).to be_nil
+      cache = memcache.get "User:company_name:EMC:department:Mozy:employee_id:12345"
+      expect(cache).to be_nil
+    end
+  end
+end