togglecraft 1.0.0

data/spec/togglecraft/cache_spec.rb

@@ -0,0 +1,274 @@
+# frozen_string_literal: true
+
+RSpec.describe ToggleCraft::Cache do
+  let(:cache) { described_class.new(ttl: 2) } # 2 seconds for faster tests
+
+  after do
+    cache.destroy
+  end
+
+  describe '#initialize' do
+    it 'creates a cache with default memory adapter' do
+      cache = described_class.new
+      expect(cache.adapter).to be_a(ToggleCraft::CacheAdapters::MemoryAdapter)
+      cache.destroy
+    end
+
+    it 'uses default TTL of 300 seconds' do
+      cache = described_class.new
+      expect(cache.default_ttl).to eq(300)
+      cache.destroy
+    end
+
+    it 'accepts custom TTL' do
+      cache = described_class.new(ttl: 600)
+      expect(cache.default_ttl).to eq(600)
+      cache.destroy
+    end
+
+    it 'accepts custom adapter' do
+      custom_adapter = ToggleCraft::CacheAdapters::MemoryAdapter.new
+      cache = described_class.new(adapter: custom_adapter)
+      expect(cache.adapter).to eq(custom_adapter)
+      cache.destroy
+    end
+  end
+
+  describe '#set and #get' do
+    it 'stores and retrieves values' do
+      cache.set('key', 'value')
+      expect(cache.get('key')).to eq('value')
+    end
+
+    it 'returns nil for non-existent keys' do
+      expect(cache.get('missing')).to be_nil
+    end
+
+    it 'stores different types of values' do
+      cache.set('string', 'text')
+      cache.set('number', 123)
+      cache.set('hash', { foo: 'bar' })
+      cache.set('array', [1, 2, 3])
+      cache.set('boolean', true)
+
+      expect(cache.get('string')).to eq('text')
+      expect(cache.get('number')).to eq(123)
+      expect(cache.get('hash')).to eq({ foo: 'bar' })
+      expect(cache.get('array')).to eq([1, 2, 3])
+      expect(cache.get('boolean')).to be true
+    end
+  end
+
+  describe 'TTL and expiration' do
+    it 'expires entries after TTL' do
+      cache.set('key', 'value')
+      expect(cache.get('key')).to eq('value')
+
+      # Wait for expiration (TTL is 2 seconds in test)
+      # Sleep a bit longer to account for timing precision
+      sleep 2.5
+
+      expect(cache.get('key')).to be_nil
+    end
+
+    it 'allows custom TTL per entry' do
+      cache.set('short', 'value1', ttl: 1)
+      cache.set('long', 'value2', ttl: 10)
+
+      # Sleep a bit longer to ensure expiration
+      sleep 1.5
+
+      expect(cache.get('short')).to be_nil
+      expect(cache.get('long')).to eq('value2')
+    end
+  end
+
+  describe '#delete' do
+    it 'removes an entry' do
+      cache.set('key', 'value')
+      expect(cache.delete('key')).to be true
+      expect(cache.get('key')).to be_nil
+    end
+
+    it 'returns false for non-existent keys' do
+      expect(cache.delete('missing')).to be false
+    end
+  end
+
+  describe '#clear' do
+    it 'removes all entries' do
+      cache.set('key1', 'value1')
+      cache.set('key2', 'value2')
+      cache.set('key3', 'value3')
+
+      cache.clear
+
+      expect(cache.get('key1')).to be_nil
+      expect(cache.get('key2')).to be_nil
+      expect(cache.get('key3')).to be_nil
+    end
+  end
+
+  describe '#has?' do
+    it 'returns true for existing non-expired entries' do
+      cache.set('key', 'value')
+      expect(cache.has?('key')).to be true
+    end
+
+    it 'returns false for non-existent keys' do
+      expect(cache.has?('missing')).to be false
+    end
+
+    it 'returns false for expired entries' do
+      cache.set('key', 'value', ttl: 1)
+      sleep 1.5
+      expect(cache.has?('key')).to be false
+    end
+
+    it 'returns false after deletion' do
+      cache.set('key', 'value')
+      cache.delete('key')
+      expect(cache.has?('key')).to be false
+    end
+  end
+
+  describe '#clear_by_prefix' do
+    it 'deletes all keys matching prefix' do
+      cache.set('user:123', 'data1')
+      cache.set('user:456', 'data2')
+      cache.set('session:789', 'data3')
+
+      cache.clear_by_prefix('user:')
+
+      expect(cache.get('user:123')).to be_nil
+      expect(cache.get('user:456')).to be_nil
+      expect(cache.get('session:789')).to eq('data3')
+    end
+
+    it 'does not delete keys not matching prefix' do
+      cache.set('flag:test', 'data1')
+      cache.set('eval:test', 'data2')
+
+      cache.clear_by_prefix('flag:')
+
+      expect(cache.get('flag:test')).to be_nil
+      expect(cache.get('eval:test')).to eq('data2')
+    end
+  end
+
+  describe '#all_flags' do
+    it 'returns all cached flags' do
+      cache.set('flag:feature1', { enabled: true })
+      cache.set('flag:feature2', { enabled: false })
+      cache.set('other:key', 'not a flag')
+
+      flags = cache.all_flags
+      expect(flags).to eq({
+                            'feature1' => { enabled: true },
+                            'feature2' => { enabled: false }
+                          })
+    end
+
+    it 'excludes expired flags' do
+      cache.set('flag:feature1', { enabled: true })
+      cache.set('flag:feature2', { enabled: false }, ttl: 1)
+
+      sleep 1.5
+
+      flags = cache.all_flags
+      expect(flags).to eq({
+                            'feature1' => { enabled: true }
+                          })
+    end
+
+    it 'returns empty hash when no flags exist' do
+      expect(cache.all_flags).to eq({})
+    end
+  end
+
+  describe '#set_all_flags' do
+    it 'stores multiple flags at once' do
+      flags = {
+        'feature1' => { enabled: true },
+        'feature2' => { enabled: false },
+        'feature3' => { enabled: true }
+      }
+
+      cache.set_all_flags(flags)
+
+      expect(cache.get('flag:feature1')).to eq({ enabled: true })
+      expect(cache.get('flag:feature2')).to eq({ enabled: false })
+      expect(cache.get('flag:feature3')).to eq({ enabled: true })
+    end
+
+    it 'accepts custom TTL for all flags' do
+      flags = {
+        'feature1' => { enabled: true },
+        'feature2' => { enabled: false }
+      }
+
+      cache.set_all_flags(flags, ttl: 1)
+
+      sleep 1.5
+
+      expect(cache.get('flag:feature1')).to be_nil
+      expect(cache.get('flag:feature2')).to be_nil
+    end
+
+    it 'overwrites existing flags' do
+      cache.set('flag:feature1', { enabled: false })
+      cache.set_all_flags({ 'feature1' => { enabled: true } })
+
+      expect(cache.get('flag:feature1')).to eq({ enabled: true })
+    end
+  end
+
+  describe 'automatic cleanup' do
+    it 'removes expired entries automatically' do
+      cache.set('key1', 'value1', ttl: 1)
+      cache.set('key2', 'value2', ttl: 10)
+
+      # Wait for expiration and cleanup cycle
+      sleep 1.5
+
+      # Trigger cleanup manually for testing
+      cache.send(:cleanup_expired)
+
+      # Adapter should not have the expired key
+      expect(cache.adapter.has?('key1')).to be false
+      expect(cache.get('key2')).to eq('value2')
+    end
+  end
+
+  describe '#destroy' do
+    it 'stops cleanup thread and clears cache' do
+      cache.set('key', 'value')
+      cache.destroy
+
+      expect(cache.get('key')).to be_nil
+      expect(cache.instance_variable_get(:@cleanup_thread)).to be_nil
+    end
+
+    it 'is safe to call multiple times' do
+      expect { cache.destroy }.not_to raise_error
+      expect { cache.destroy }.not_to raise_error
+    end
+  end
+
+  describe 'concurrent access' do
+    it 'handles concurrent reads and writes safely' do
+      threads = 10.times.map do |i|
+        Thread.new do
+          10.times do |j|
+            key = "thread_#{i}_flag_#{j}"
+            value = { enabled: (j % 2).zero? }
+            cache.set(key, value)
+            expect(cache.get(key)).to eq(value)
+          end
+        end
+      end
+
+      threads.each(&:join)
+    end
+  end
+end