mudis 0.8.0 → 0.9.0

data/spec/guardrails_spec.rb

@@ -1,138 +1,138 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "climate_control"
-
-RSpec.describe "Mudis TTL Guardrail" do # rubocop:disable Metrics/BlockLength
-  before do
-    Mudis.reset!
-    Mudis.configure do |c|
-      c.max_ttl = 60 # 60 seconds max
-    end
-  end
-
-  describe "default_ttl configuration" do # rubocop:disable Metrics/BlockLength
-    before do
-      Mudis.reset!
-      Mudis.configure do |c|
-        c.default_ttl = 60
-      end
-    end
-
-    it "applies default_ttl when expires_in is nil" do
-      Mudis.write("foo", "bar") # no explicit expires_in
-      meta = Mudis.inspect("foo")
-      expect(meta[:expires_at]).not_to be_nil
-      expect(meta[:expires_at]).to be_within(5).of(Time.now + 60)
-    end
-
-    it "respects expires_in if explicitly given" do
-      Mudis.write("short_lived", "bar", expires_in: 10)
-      meta = Mudis.inspect("short_lived")
-      expect(meta[:expires_at]).not_to be_nil
-      expect(meta[:expires_at]).to be_within(5).of(Time.now + 10)
-    end
-
-    it "applies max_ttl over default_ttl if both are set" do
-      Mudis.configure do |c|
-        c.default_ttl = 120
-        c.max_ttl = 30
-      end
-
-      Mudis.write("capped", "baz") # no explicit expires_in
-      meta = Mudis.inspect("capped")
-      expect(meta[:expires_at]).not_to be_nil
-      expect(meta[:expires_at]).to be_within(5).of(Time.now + 30)
-    end
-
-    it "stores forever if default_ttl and expires_in are nil" do
-      Mudis.configure do |c|
-        c.default_ttl = nil
-      end
-
-      Mudis.write("forever", "ever")
-      meta = Mudis.inspect("forever")
-      expect(meta[:expires_at]).to be_nil
-    end
-  end
-
-  it "clamps expires_in to max_ttl if it exceeds max_ttl" do
-    Mudis.write("foo", "bar", expires_in: 300) # user requests 5 minutes
-
-    metadata = Mudis.inspect("foo")
-    ttl = metadata[:expires_at] - metadata[:created_at]
-
-    expect(ttl).to be <= 60
-    expect(ttl).to be > 0
-  end
-
-  it "respects expires_in if below max_ttl" do
-    Mudis.write("bar", "baz", expires_in: 30) # under the max_ttl
-
-    metadata = Mudis.inspect("bar")
-    ttl = metadata[:expires_at] - metadata[:created_at]
-
-    expect(ttl).to be_within(1).of(30)
-  end
-
-  it "allows nil expires_in (no expiry) if not required" do
-    Mudis.write("baz", "no expiry")
-
-    metadata = Mudis.inspect("baz")
-    expect(metadata[:expires_at]).to be_nil
-  end
-end
-
-RSpec.describe "Mudis Configuration Guardrails" do # rubocop:disable Metrics/BlockLength
-  after { Mudis.reset! }
-
-  describe "bucket configuration" do
-    it "defaults to 32 buckets if ENV is nil" do
-      Mudis.instance_variable_set(:@buckets, nil) # force recomputation
-      ClimateControl.modify(MUDIS_BUCKETS: nil) do
-        expect(Mudis.send(:buckets)).to eq(32)
-      end
-    end
-
-    it "raises if MUDIS_BUCKETS is 0 or less" do
-      expect do
-        Mudis.instance_variable_set(:@buckets, nil) # force recomputation
-        ClimateControl.modify(MUDIS_BUCKETS: "0") { Mudis.send(:buckets) }
-      end.to raise_error(ArgumentError, /bucket count must be > 0/)
-
-      expect do
-        Mudis.instance_variable_set(:@buckets, nil) # force recomputation
-        ClimateControl.modify(MUDIS_BUCKETS: "-5") { Mudis.send(:buckets) }
-      end.to raise_error(ArgumentError, /bucket count must be > 0/)
-    end
-  end
-
-  describe "memory configuration" do
-    it "raises if max_bytes is set to 0 or less" do
-      expect do
-        Mudis.max_bytes = 0
-      end.to raise_error(ArgumentError, /max_bytes must be > 0/)
-
-      expect do
-        Mudis.max_bytes = -1
-      end.to raise_error(ArgumentError, /max_bytes must be > 0/)
-    end
-
-    it "raises if max_value_bytes is 0 or less via config" do
-      expect do
-        Mudis.configure do |c|
-          c.max_value_bytes = 0
-        end
-      end.to raise_error(ArgumentError, /max_value_bytes must be > 0/)
-    end
-
-    it "raises if max_value_bytes exceeds max_bytes" do
-      expect do
-        Mudis.configure do |c|
-          c.max_bytes = 1_000_000
-          c.max_value_bytes = 2_000_000
-        end
-      end.to raise_error(ArgumentError, /max_value_bytes cannot exceed max_bytes/)
-    end
-  end
-end
+# frozen_string_literal: true
+
+require "spec_helper"
+require "climate_control"
+
+RSpec.describe "Mudis TTL Guardrail" do # rubocop:disable Metrics/BlockLength
+  before do
+    Mudis.reset!
+    Mudis.configure do |c|
+      c.max_ttl = 60 # 60 seconds max
+    end
+  end
+
+  describe "default_ttl configuration" do # rubocop:disable Metrics/BlockLength
+    before do
+      Mudis.reset!
+      Mudis.configure do |c|
+        c.default_ttl = 60
+      end
+    end
+
+    it "applies default_ttl when expires_in is nil" do
+      Mudis.write("foo", "bar") # no explicit expires_in
+      meta = Mudis.inspect("foo")
+      expect(meta[:expires_at]).not_to be_nil
+      expect(meta[:expires_at]).to be_within(5).of(Time.now + 60)
+    end
+
+    it "respects expires_in if explicitly given" do
+      Mudis.write("short_lived", "bar", expires_in: 10)
+      meta = Mudis.inspect("short_lived")
+      expect(meta[:expires_at]).not_to be_nil
+      expect(meta[:expires_at]).to be_within(5).of(Time.now + 10)
+    end
+
+    it "applies max_ttl over default_ttl if both are set" do
+      Mudis.configure do |c|
+        c.default_ttl = 120
+        c.max_ttl = 30
+      end
+
+      Mudis.write("capped", "baz") # no explicit expires_in
+      meta = Mudis.inspect("capped")
+      expect(meta[:expires_at]).not_to be_nil
+      expect(meta[:expires_at]).to be_within(5).of(Time.now + 30)
+    end
+
+    it "stores forever if default_ttl and expires_in are nil" do
+      Mudis.configure do |c|
+        c.default_ttl = nil
+      end
+
+      Mudis.write("forever", "ever")
+      meta = Mudis.inspect("forever")
+      expect(meta[:expires_at]).to be_nil
+    end
+  end
+
+  it "clamps expires_in to max_ttl if it exceeds max_ttl" do
+    Mudis.write("foo", "bar", expires_in: 300) # user requests 5 minutes
+
+    metadata = Mudis.inspect("foo")
+    ttl = metadata[:expires_at] - metadata[:created_at]
+
+    expect(ttl).to be <= 60
+    expect(ttl).to be > 0
+  end
+
+  it "respects expires_in if below max_ttl" do
+    Mudis.write("bar", "baz", expires_in: 30) # under the max_ttl
+
+    metadata = Mudis.inspect("bar")
+    ttl = metadata[:expires_at] - metadata[:created_at]
+
+    expect(ttl).to be_within(1).of(30)
+  end
+
+  it "allows nil expires_in (no expiry) if not required" do
+    Mudis.write("baz", "no expiry")
+
+    metadata = Mudis.inspect("baz")
+    expect(metadata[:expires_at]).to be_nil
+  end
+end
+
+RSpec.describe "Mudis Configuration Guardrails" do # rubocop:disable Metrics/BlockLength
+  after { Mudis.reset! }
+
+  describe "bucket configuration" do
+    it "defaults to 32 buckets if ENV is nil" do
+      Mudis.instance_variable_set(:@buckets, nil) # force recomputation
+      ClimateControl.modify(MUDIS_BUCKETS: nil) do
+        expect(Mudis.send(:buckets)).to eq(32)
+      end
+    end
+
+    it "raises if MUDIS_BUCKETS is 0 or less" do
+      expect do
+        Mudis.instance_variable_set(:@buckets, nil) # force recomputation
+        ClimateControl.modify(MUDIS_BUCKETS: "0") { Mudis.send(:buckets) }
+      end.to raise_error(ArgumentError, /bucket count must be > 0/)
+
+      expect do
+        Mudis.instance_variable_set(:@buckets, nil) # force recomputation
+        ClimateControl.modify(MUDIS_BUCKETS: "-5") { Mudis.send(:buckets) }
+      end.to raise_error(ArgumentError, /bucket count must be > 0/)
+    end
+  end
+
+  describe "memory configuration" do
+    it "raises if max_bytes is set to 0 or less" do
+      expect do
+        Mudis.max_bytes = 0
+      end.to raise_error(ArgumentError, /max_bytes must be > 0/)
+
+      expect do
+        Mudis.max_bytes = -1
+      end.to raise_error(ArgumentError, /max_bytes must be > 0/)
+    end
+
+    it "raises if max_value_bytes is 0 or less via config" do
+      expect do
+        Mudis.configure do |c|
+          c.max_value_bytes = 0
+        end
+      end.to raise_error(ArgumentError, /max_value_bytes must be > 0/)
+    end
+
+    it "raises if max_value_bytes exceeds max_bytes" do
+      expect do
+        Mudis.configure do |c|
+          c.max_bytes = 1_000_000
+          c.max_value_bytes = 2_000_000
+        end
+      end.to raise_error(ArgumentError, /max_value_bytes cannot exceed max_bytes/)
+    end
+  end
+end

data/spec/memory_guard_spec.rb

@@ -1,33 +1,33 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Mudis Memory Guardrails" do
-  before do
-    Mudis.reset!
-    Mudis.stop_expiry_thread
-    Mudis.instance_variable_set(:@buckets, 1)
-    Mudis.instance_variable_set(:@stores, [{}])
-    Mudis.instance_variable_set(:@mutexes, [Mutex.new])
-    Mudis.instance_variable_set(:@lru_heads, [nil])
-    Mudis.instance_variable_set(:@lru_tails, [nil])
-    Mudis.instance_variable_set(:@lru_nodes, [{}])
-    Mudis.instance_variable_set(:@current_bytes, [0])
-
-    Mudis.max_value_bytes = nil
-    Mudis.instance_variable_set(:@threshold_bytes, 1_000_000)
-    Mudis.hard_memory_limit = true
-    Mudis.instance_variable_set(:@max_bytes, 100)
-  end
-
-  it "rejects writes that exceed max memory" do
-    big_value = "a" * 90
-    Mudis.write("a", big_value)
-    expect(Mudis.read("a")).to eq(big_value)
-
-    big_value2 = "b" * 90
-    Mudis.write("b", big_value2)
-    expect(Mudis.read("b")).to be_nil
-    expect(Mudis.metrics[:rejected]).to be > 0
-  end
-end
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis Memory Guardrails" do
+  before do
+    Mudis.reset!
+    Mudis.stop_expiry_thread
+    Mudis.instance_variable_set(:@buckets, 1)
+    Mudis.instance_variable_set(:@stores, [{}])
+    Mudis.instance_variable_set(:@mutexes, [Mutex.new])
+    Mudis.instance_variable_set(:@lru_heads, [nil])
+    Mudis.instance_variable_set(:@lru_tails, [nil])
+    Mudis.instance_variable_set(:@lru_nodes, [{}])
+    Mudis.instance_variable_set(:@current_bytes, [0])
+
+    Mudis.max_value_bytes = nil
+    Mudis.instance_variable_set(:@threshold_bytes, 1_000_000)
+    Mudis.hard_memory_limit = true
+    Mudis.instance_variable_set(:@max_bytes, 100)
+  end
+
+  it "rejects writes that exceed max memory" do
+    big_value = "a" * 90
+    Mudis.write("a", big_value)
+    expect(Mudis.read("a")).to eq(big_value)
+
+    big_value2 = "b" * 90
+    Mudis.write("b", big_value2)
+    expect(Mudis.read("b")).to be_nil
+    expect(Mudis.metrics[:rejected]).to be > 0
+  end
+end

data/spec/metrics_spec.rb

@@ -1,34 +1,34 @@
-# frozen_string_literal: true
-
-require_relative "spec_helper"
-
-RSpec.describe "Mudis Metrics" do # rubocop:disable Metrics/BlockLength
-  it "tracks hits and misses" do
-    Mudis.write("hit_me", "value")
-    Mudis.read("hit_me")
-    Mudis.read("miss_me")
-    metrics = Mudis.metrics
-    expect(metrics[:hits]).to eq(1)
-    expect(metrics[:misses]).to eq(1)
-  end
-
-  it "includes per-bucket stats" do
-    Mudis.write("a", "x" * 50)
-    metrics = Mudis.metrics
-    expect(metrics).to include(:buckets)
-    expect(metrics[:buckets]).to be_an(Array)
-    expect(metrics[:buckets].first).to include(:index, :keys, :memory_bytes, :lru_size)
-  end
-
-  it "resets only the metrics without clearing cache" do
-    Mudis.write("metrics_key", "value")
-    Mudis.read("metrics_key")
-    Mudis.read("missing_key")
-    expect(Mudis.metrics[:hits]).to eq(1)
-    expect(Mudis.metrics[:misses]).to eq(1)
-    Mudis.reset_metrics!
-    expect(Mudis.metrics[:hits]).to eq(0)
-    expect(Mudis.metrics[:misses]).to eq(0)
-    expect(Mudis.read("metrics_key")).to eq("value")
-  end
-end
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe "Mudis Metrics" do # rubocop:disable Metrics/BlockLength
+  it "tracks hits and misses" do
+    Mudis.write("hit_me", "value")
+    Mudis.read("hit_me")
+    Mudis.read("miss_me")
+    metrics = Mudis.metrics
+    expect(metrics[:hits]).to eq(1)
+    expect(metrics[:misses]).to eq(1)
+  end
+
+  it "includes per-bucket stats" do
+    Mudis.write("a", "x" * 50)
+    metrics = Mudis.metrics
+    expect(metrics).to include(:buckets)
+    expect(metrics[:buckets]).to be_an(Array)
+    expect(metrics[:buckets].first).to include(:index, :keys, :memory_bytes, :lru_size)
+  end
+
+  it "resets only the metrics without clearing cache" do
+    Mudis.write("metrics_key", "value")
+    Mudis.read("metrics_key")
+    Mudis.read("missing_key")
+    expect(Mudis.metrics[:hits]).to eq(1)
+    expect(Mudis.metrics[:misses]).to eq(1)
+    Mudis.reset_metrics!
+    expect(Mudis.metrics[:hits]).to eq(0)
+    expect(Mudis.metrics[:misses]).to eq(0)
+    expect(Mudis.read("metrics_key")).to eq("value")
+  end
+end

data/spec/modules/expiry_spec.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+
+RSpec.describe Mudis::Expiry do
+  let(:test_class) do
+    Class.new do
+      extend Mudis::Expiry
+      
+      @expiry_thread = nil
+      @stop_expiry = false
+      @buckets = 2
+      @mutexes = Array.new(2) { Mutex.new }
+      @stores = Array.new(2) { {} }
+      @max_ttl = nil
+      @default_ttl = nil
+      
+      class << self
+        attr_accessor :expiry_thread, :stop_expiry, :buckets, :mutexes, :stores, :max_ttl, :default_ttl
+        
+        def evict_key(idx, key)
+          @stores[idx].delete(key)
+        end
+      end
+    end
+  end
+
+  after do
+    test_class.stop_expiry_thread if test_class.expiry_thread&.alive?
+  end
+
+  describe "#start_expiry_thread" do
+    it "starts a background cleanup thread" do
+      test_class.start_expiry_thread(interval: 0.1)
+      
+      expect(test_class.expiry_thread).to be_alive
+    end
+
+    it "does not start duplicate thread if already running" do
+      test_class.start_expiry_thread(interval: 0.1)
+      first_thread = test_class.expiry_thread
+      
+      test_class.start_expiry_thread(interval: 0.1)
+      
+      expect(test_class.expiry_thread).to eq(first_thread)
+    end
+
+    it "periodically calls cleanup_expired!" do
+      allow(test_class).to receive(:cleanup_expired!)
+      
+      test_class.start_expiry_thread(interval: 0.05)
+      sleep 0.15
+      
+      expect(test_class).to have_received(:cleanup_expired!).at_least(:once)
+    end
+  end
+
+  describe "#stop_expiry_thread" do
+    it "stops the background thread" do
+      test_class.start_expiry_thread(interval: 0.1)
+      
+      test_class.stop_expiry_thread
+      
+      expect(test_class.expiry_thread).to be_nil
+    end
+
+    it "sets stop signal" do
+      test_class.start_expiry_thread(interval: 0.1)
+      
+      test_class.stop_expiry_thread
+      
+      expect(test_class.stop_expiry).to be true
+    end
+
+    it "does nothing if thread is not running" do
+      expect { test_class.stop_expiry_thread }.not_to raise_error
+    end
+  end
+
+  describe "#cleanup_expired!" do
+    it "removes expired keys from all buckets" do
+      now = Time.now
+      test_class.stores[0]["expired"] = { expires_at: now - 10 }
+      test_class.stores[0]["valid"] = { expires_at: now + 10 }
+      test_class.stores[1]["also_expired"] = { expires_at: now - 5 }
+      
+      test_class.cleanup_expired!
+      
+      expect(test_class.stores[0]).not_to have_key("expired")
+      expect(test_class.stores[0]).to have_key("valid")
+      expect(test_class.stores[1]).not_to have_key("also_expired")
+    end
+
+    it "keeps keys without expiration" do
+      test_class.stores[0]["no_expiry"] = { expires_at: nil }
+      
+      test_class.cleanup_expired!
+      
+      expect(test_class.stores[0]).to have_key("no_expiry")
+    end
+
+    it "is thread-safe" do
+      10.times do |i|
+        test_class.stores[0]["key#{i}"] = { expires_at: Time.now - 1 }
+      end
+      
+      threads = 3.times.map do
+        Thread.new { test_class.cleanup_expired! }
+      end
+      
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+  end
+
+  describe "#effective_ttl (private)" do
+    it "returns provided expires_in when no constraints" do
+      result = test_class.send(:effective_ttl, 300)
+      
+      expect(result).to eq(300)
+    end
+
+    it "returns nil when expires_in is nil and no default" do
+      result = test_class.send(:effective_ttl, nil)
+      
+      expect(result).to be_nil
+    end
+
+    it "uses default_ttl when expires_in is nil" do
+      test_class.default_ttl = 600
+      
+      result = test_class.send(:effective_ttl, nil)
+      
+      expect(result).to eq(600)
+    end
+
+    it "clamps to max_ttl when expires_in exceeds it" do
+      test_class.max_ttl = 100
+      
+      result = test_class.send(:effective_ttl, 500)
+      
+      expect(result).to eq(100)
+    end
+
+    it "allows expires_in below max_ttl" do
+      test_class.max_ttl = 1000
+      
+      result = test_class.send(:effective_ttl, 500)
+      
+      expect(result).to eq(500)
+    end
+
+    it "applies max_ttl over default_ttl" do
+      test_class.max_ttl = 100
+      test_class.default_ttl = 500
+      
+      result = test_class.send(:effective_ttl, nil)
+      
+      expect(result).to eq(100)
+    end
+
+    it "returns nil when both expires_in and default_ttl are nil" do
+      test_class.max_ttl = 1000
+      test_class.default_ttl = nil
+      
+      result = test_class.send(:effective_ttl, nil)
+      
+      expect(result).to be_nil
+    end
+  end
+end