mudis 0.7.2 → 0.7.3

data/spec/eviction_spec.rb

@@ -1,29 +1,29 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-RSpec.describe "Mudis LRU Eviction" 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.hard_memory_limit = false
-    Mudis.instance_variable_set(:@threshold_bytes, 60)
-    Mudis.max_value_bytes = 100
-  end
-
-  it "evicts old entries when size limit is reached" do
-    Mudis.write("a", "a" * 50)
-    Mudis.write("b", "b" * 50)
-
-    expect(Mudis.read("a")).to be_nil
-    expect(Mudis.read("b")).not_to be_nil
-  end
-end
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Mudis LRU Eviction" 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.hard_memory_limit = false
+    Mudis.instance_variable_set(:@threshold_bytes, 60)
+    Mudis.max_value_bytes = 100
+  end
+
+  it "evicts old entries when size limit is reached" do
+    Mudis.write("a", "a" * 50)
+    Mudis.write("b", "b" * 50)
+
+    expect(Mudis.read("a")).to be_nil
+    expect(Mudis.read("b")).not_to be_nil
+  end
+end

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