atomic_cache 0.1.0.rc1 → 0.2.1.rc2

data/spec/atomic_cache/concerns/global_lmt_cache_concern_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'AtomicCacheConcern' do
+  let(:key_storage) { DefaultConfig.instance.key_storage }
+  let(:cache_storage) { DefaultConfig.instance.cache_storage }
+
+  subject do
+    class Foo1
+      include AtomicCache::GlobalLMTCacheConcern
+
+      def example_method
+        atomic_cache.fetch(cache_keyspace(:foo)) { 'bar' }
+      end
+    end
+    Foo1
+  end
+
+  before(:context) do
+    DefaultConfig.instance.reset
+    DefaultConfig.configure do |cfg|
+      cfg.cache_storage = AtomicCache::Storage::SharedMemory.new
+      cfg.key_storage = AtomicCache::Storage::SharedMemory.new
+      cfg.timestamp_formatter = Proc.new { |time| time.to_i }
+    end
+  end
+
+  before(:each) do
+    key_storage.reset
+    cache_storage.reset
+  end
+
+  context 'atomic_cache' do
+    it 'initializes a cache client' do
+      expect(subject).to respond_to(:atomic_cache)
+      expect(subject.atomic_cache).to be_a(AtomicCacheClient)
+      expect(subject.new.atomic_cache).to be_a(AtomicCacheClient)
+    end
+
+    it 'uses the name of the class in the default keyspace' do
+      subject.expire_cache
+      expect(key_storage.store).to have_key(:'foo1:lmt')
+    end
+
+    it 'allows methods to be defined that utilize the cache' do
+      expect(subject.new.example_method).to eq('bar')
+    end
+  end
+
+  context '#expire_cache' do
+    it 'updates the last modified time' do
+      time = Time.local(2018, 1, 1, 15, 30, 0)
+      subject.expire_cache(time)
+      expect(key_storage.store).to have_key(:'foo1:lmt')
+      expect(key_storage.read(:'foo1:lmt')).to eq(time.to_i)
+    end
+
+    it 'expires all the keyspaces for this class' do
+      old_time = Time.local(2018, 1, 1, 15, 30, 0)
+      new_time = Time.local(2018, 1, 1, 15, 40, 0)
+      ns1 = subject.cache_keyspace(:bar)
+      ns2 = subject.cache_keyspace(:buz)
+
+      Timecop.freeze(old_time) do
+        subject.atomic_cache.fetch(ns1) { 'bar' }
+        subject.atomic_cache.fetch(ns2) { 'buz' }
+      end
+
+      Timecop.freeze(new_time) do
+        subject.expire_cache
+        lmt = subject.last_modified_time
+
+        # some other process writes new values
+        cache_storage.set("foo1:bar:#{lmt}", 'new-bar')
+        cache_storage.set("foo1:buz:#{lmt}", 'new-buz')
+
+        ns1_value = subject.atomic_cache.fetch(ns1)
+        ns2_value = subject.atomic_cache.fetch(ns2)
+
+        expect(ns1_value).to eq('new-bar')
+        expect(ns2_value).to eq('new-buz')
+      end
+    end
+
+    it 'works on the instance method' do
+      time = Time.local(2018, 1, 1, 15, 30, 0)
+      subject.new.expire_cache(time)
+      expect(key_storage.store).to have_key(:'foo1:lmt')
+      expect(key_storage.read(:'foo1:lmt')).to eq(time.to_i)
+    end
+  end
+
+  context '#cache_keyspace' do
+    it 'returns a child keyspace of the class keyspace' do
+      ns = subject.cache_keyspace(:fuz, :baz)
+      expect(ns).to be_a(Keyspace)
+      expect(ns.namespace).to eq(['foo1', :fuz, :baz])
+    end
+  end
+
+  context 'keyspace macros' do
+    subject do
+      class Foo2
+        include AtomicCache::GlobalLMTCacheConcern
+        cache_version(3)
+        cache_class('foo')
+      end
+      Foo2
+    end
+
+    it 'uses the given version and cache_class become part of the cache keyspace' do
+      subject.expire_cache
+      expect(key_storage.store).to have_key(:'foo:v3:lmt')
+    end
+  end
+
+  context 'storage macros' do
+    subject do
+      class Foo3
+        include AtomicCache::GlobalLMTCacheConcern
+        cache_key_storage('keystore')
+        cache_value_storage('valuestore')
+      end
+      Foo3
+    end
+
+    it 'sets the storage for the class' do
+      cache_store = subject.atomic_cache.instance_variable_get(:@storage)
+      expect(cache_store).to eq('valuestore')
+
+      key_store = subject.instance_variable_get(:@timestamp_manager).instance_variable_get(:@storage)
+      expect(key_store).to eq('keystore')
+    end
+  end
+
+end

data/spec/atomic_cache/default_config_spec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'DefaultConfig' do
+  subject { DefaultConfig }
+
+  context '#configure' do
+    it 'configures the singleton' do
+      subject.configure do |manager|
+        manager.namespace = 'foo'
+      end
+      expect(subject.instance.namespace).to eq('foo')
+
+      # change it a 2nd time to make sure it sticks
+      subject.configure do |manager|
+        manager.namespace = 'bar'
+      end
+      expect(subject.instance.namespace).to eq('bar')
+    end
+  end
+end

data/spec/atomic_cache/key/keyspace_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Keyspace' do
+  subject { AtomicCache::Keyspace.new(namespace: ['foo', 'bar'], root: 'foo') }
+
+  context '#initialize' do
+
+    it 'sorts sortable values before hashing' do
+      ks1 = AtomicCache::Keyspace.new(namespace: ['foo', [1, 2, 3]])
+      ks2 = AtomicCache::Keyspace.new(namespace: ['foo', [3, 2, 1]])
+      expect(ks1.namespace).to eq(ks2.namespace)
+    end
+
+    context 'namespace' do
+      it 'accepts nil' do
+        ks = AtomicCache::Keyspace.new(namespace: nil)
+        expect(ks.namespace).to eq([])
+      end
+
+      it 'accepts single values' do
+        ks = AtomicCache::Keyspace.new(namespace: 'foo')
+        expect(ks.namespace).to eq(['foo'])
+      end
+
+      it 'hashes non-primitive types' do
+        ids = [1,2,3]
+        ks1 = AtomicCache::Keyspace.new(namespace: ['foo', ids])
+        hash = ks1.send(:hexhash, ids)
+        expect(ks1.namespace).to eq(['foo', hash])
+      end
+
+      it 'leaves primitives alone' do
+        ks1 = AtomicCache::Keyspace.new(namespace: ['foo', :foo, 5])
+        expect(ks1.namespace).to eq(['foo', :foo, 5])
+      end
+
+      it 'expands timestamps' do
+        formatter = Proc.new { |t| 'formatted' }
+        ks = AtomicCache::Keyspace.new(namespace: Time.new, timestamp_formatter: formatter)
+        expect(ks.namespace).to eq(['formatted'])
+      end
+    end
+  end
+
+  context '#child' do
+    it 'extends the keyspace' do
+      ks2 = subject.child([:buz, :baz])
+      expect(ks2.namespace).to eq(['foo', 'bar', :buz, :baz])
+    end
+  end
+
+  context '#key' do
+    it 'return a key of the segments' do
+      expect(subject.key).to eq('foo:bar')
+    end
+
+    it 'return the key with the suffix' do
+      expect(subject.key('baz')).to eq('foo:bar:baz')
+    end
+  end
+
+end

data/spec/atomic_cache/key/last_mod_time_key_manager_spec.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'LastModTimeKeyManager' do
+  let(:id) { :foo }
+  let(:timestamp) { 1513720308 }
+  let(:storage) { AtomicCache::Storage::InstanceMemory.new }
+  let(:timestamp_keyspace) { Keyspace.new(namespace: ['ts'], root: 'foo') }
+  let(:req_keyspace) { Keyspace.new(namespace: ['ns'], root: 'bar') }
+
+  subject do
+    AtomicCache::LastModTimeKeyManager.new(
+      keyspace: timestamp_keyspace,
+      storage: storage,
+      timestamp_formatter: Proc.new { |t| t.to_i }
+    )
+  end
+
+  it 'returns the #next_key' do
+    expect(subject.next_key(req_keyspace, timestamp)).to eq('ns:1513720308')
+  end
+
+  it 'gets and sets the #last_known_key' do
+    subject.promote(req_keyspace, last_known_key: 'bar:foo:1513600308', timestamp: timestamp)
+    expect(subject.last_known_key(req_keyspace)).to eq('bar:foo:1513600308')
+    expect(storage.store).to have_key(:'ns:lkk')
+  end
+
+  it 'returns the #last_mod_time_key' do
+    expect(subject.last_modified_time_key).to eq('ts:lmt')
+  end
+
+  it 'locks and unlocks' do
+    locked = subject.lock(req_keyspace, 100)
+    expect(storage.store).to have_key(:'ns:lock')
+    expect(locked).to eq(true)
+
+    subject.unlock(req_keyspace)
+    expect(storage.store).to_not have_key(:'ns:lock')
+  end
+
+  it 'promotes a timestamp and last known key' do
+    subject.promote(req_keyspace, last_known_key: 'asdf', timestamp: timestamp)
+    expect(storage.read(:'ns:lkk')).to eq('asdf')
+    expect(storage.read(:'ts:lmt')).to eq(timestamp)
+    expect(subject.last_modified_time).to eq(timestamp)
+  end
+
+  context '#last_modified_time=' do
+    it 'returns the last modified time' do
+      subject.last_modified_time = timestamp
+      expect(storage.read(:'ts:lmt')).to eq(timestamp)
+      expect(subject.last_modified_time).to eq(timestamp)
+    end
+
+    it 'formats Time' do
+      now = Time.now
+      subject.last_modified_time = now
+      expect(subject.last_modified_time).to eq(now.to_i)
+    end
+  end
+
+end

data/spec/atomic_cache/storage/dalli_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+class FakeDalli
+  def add(key, new_value, ttl, user_options); end
+  def read(key, user_options); end
+  def set(key, new_value, user_options); end
+  def delete(key, user_options); end
+end
+
+describe 'Dalli' do
+  let(:dalli_client) { FakeDalli.new }
+  subject { AtomicCache::Storage::Dalli.new(dalli_client) }
+
+  it 'delegates #set without options' do
+    expect(dalli_client).to receive(:set).with('key', 'value', {})
+    subject.set('key', 'value')
+  end
+
+  it 'delegates #read without options' do
+    expect(dalli_client).to receive(:read).with('key', {}).and_return('asdf')
+    subject.read('key')
+  end
+
+  it 'delegates #delete' do
+    expect(dalli_client).to receive(:delete).with('key')
+    subject.delete('key')
+  end
+
+  context '#add' do
+    before(:each) do
+      allow(dalli_client).to receive(:add).and_return('NOT_STORED\r\n')
+    end
+
+    it 'delegates to #add with the raw option set' do
+      expect(dalli_client).to receive(:add)
+        .with('key', 'value', 100, { foo: 'bar', raw: true })
+      subject.add('key', 'value', 100, { foo: 'bar' })
+    end
+
+    it 'returns true when the add is successful' do
+      expect(dalli_client).to receive(:add).and_return('STORED\r\n')
+      result = subject.add('key', 'value', 100)
+      expect(result).to eq(true)
+    end
+
+    it 'returns false if the key already exists' do
+      expect(dalli_client).to receive(:add).and_return('EXISTS\r\n')
+      result = subject.add('key', 'value', 100)
+      expect(result).to eq(false)
+    end
+
+    it 'returns false if the add fails' do
+      expect(dalli_client).to receive(:add).and_return('NOT_STORED\r\n')
+      result = subject.add('key', 'value', 100)
+      expect(result).to eq(false)
+    end
+  end
+
+end

data/spec/atomic_cache/storage/instance_memory_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+require_relative 'memory_spec'
+
+describe 'InstanceMemory' do
+  subject { AtomicCache::Storage::InstanceMemory.new }
+  it_behaves_like 'memory storage'
+end

data/spec/atomic_cache/storage/memory_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+shared_examples 'memory storage' do
+  before(:each) do
+    subject.reset
+  end
+
+  context '#add' do
+    it 'writes the new key if it does not already exist' do
+      result = subject.add('key', 'value', 100)
+
+      expect(subject.store).to have_key(:key)
+      expect(Marshal.load(subject.store[:key][:value])).to eq('value')
+      expect(subject.store[:key][:ttl]).to eq(100)
+      expect(result).to eq(true)
+    end
+
+    it 'does not write the key if it exists' do
+      entry = { value: Marshal.dump('foo'), ttl: 100, written_at: 100 }
+      subject.store[:key] = entry
+
+      result = subject.add('key', 'value', 200)
+      expect(result).to eq(false)
+
+      # stored values should not have changed
+      expect(subject.store).to have_key(:key)
+      expect(Marshal.load(subject.store[:key][:value])).to eq('foo')
+      expect(subject.store[:key][:ttl]).to eq(100)
+    end
+  end
+
+  context '#read' do
+    it 'returns values' do
+      subject.store[:sugar] = { value: Marshal.dump('foo') }
+      expect(subject.read('sugar')).to eq('foo')
+    end
+
+    it 'respects TTL' do
+      subject.store[:sugar] = { value: Marshal.dump('foo'), ttl: 100, written_at: Time.now - 1000 }
+      expect(subject.read('sugar')).to eq(nil)
+    end
+
+    it 'returns complex objects' do
+      class ComplexObject
+        attr_accessor :foo, :bar
+      end
+
+      obj = ComplexObject.new
+      obj.foo = 'f'
+      obj.bar = [1,2,3]
+
+      subject.set(:complex, obj)
+
+      obj2 = subject.read(:complex)
+      expect(obj2.foo).to eql('f')
+      expect(obj2.bar).to eql([1,2,3])
+    end
+  end
+
+  context '#set' do
+    it 'adds the value when not present' do
+      subject.set(:cane, 'v', expires_in: 100)
+      expect(subject.store).to have_key(:cane)
+      expect(Marshal.load(subject.store[:cane][:value])).to eq('v')
+      expect(subject.store[:cane][:ttl]).to eq(100)
+    end
+
+    it 'overwrites existing values' do
+      subject.store[:cane] = { value: 'foo', ttl: 500, written_at: 500 }
+
+      subject.set(:cane, 'v', expires_in: 100)
+      expect(subject.store).to have_key(:cane)
+      expect(Marshal.load(subject.store[:cane][:value])).to eq('v')
+      expect(subject.store[:cane][:ttl]).to eq(100)
+    end
+  end
+
+  context '#delete' do
+    it 'deletes the key' do
+      subject.store[:record] = { value: Marshal.dump('foo'), written_at: 500 }
+      subject.delete('record')
+      expect(subject.store).to_not have_key(:record)
+    end
+  end
+
+end