mudis 0.8.0 → 0.9.0

data/spec/modules/lru_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+
+RSpec.describe Mudis::LRU do
+  let(:test_class) do
+    Class.new do
+      extend Mudis::LRU
+      
+      @stores = Array.new(2) { {} }
+      @lru_heads = Array.new(2) { nil }
+      @lru_tails = Array.new(2) { nil }
+      @lru_nodes = Array.new(2) { {} }
+      @current_bytes = Array.new(2, 0)
+      
+      class << self
+        attr_accessor :stores, :lru_heads, :lru_tails, :lru_nodes, :current_bytes
+      end
+    end
+  end
+
+  describe "LRUNode" do
+    it "initializes with a key" do
+      node = Mudis::LRUNode.new("test_key")
+      
+      expect(node.key).to eq("test_key")
+      expect(node.prev).to be_nil
+      expect(node.next).to be_nil
+    end
+
+    it "allows setting prev and next" do
+      node1 = Mudis::LRUNode.new("key1")
+      node2 = Mudis::LRUNode.new("key2")
+      
+      node1.next = node2
+      node2.prev = node1
+      
+      expect(node1.next).to eq(node2)
+      expect(node2.prev).to eq(node1)
+    end
+  end
+
+  describe "#insert_lru (private)" do
+    it "inserts a node at the head of the LRU list" do
+      test_class.send(:insert_lru, 0, "key1")
+      
+      expect(test_class.lru_heads[0]).to be_a(Mudis::LRUNode)
+      expect(test_class.lru_heads[0].key).to eq("key1")
+      expect(test_class.lru_tails[0]).to eq(test_class.lru_heads[0])
+      expect(test_class.lru_nodes[0]["key1"]).to be_a(Mudis::LRUNode)
+    end
+
+    it "maintains order when inserting multiple nodes" do
+      test_class.send(:insert_lru, 0, "key1")
+      test_class.send(:insert_lru, 0, "key2")
+      test_class.send(:insert_lru, 0, "key3")
+      
+      expect(test_class.lru_heads[0].key).to eq("key3")
+      expect(test_class.lru_tails[0].key).to eq("key1")
+    end
+  end
+
+  describe "#promote_lru (private)" do
+    it "moves a node to the head of the LRU list" do
+      test_class.send(:insert_lru, 0, "key1")
+      test_class.send(:insert_lru, 0, "key2")
+      test_class.send(:insert_lru, 0, "key3")
+      
+      test_class.send(:promote_lru, 0, "key1")
+      
+      expect(test_class.lru_heads[0].key).to eq("key1")
+    end
+
+    it "does nothing if key is already at head" do
+      test_class.send(:insert_lru, 0, "key1")
+      
+      head_before = test_class.lru_heads[0]
+      test_class.send(:promote_lru, 0, "key1")
+      
+      expect(test_class.lru_heads[0].key).to eq("key1")
+    end
+
+    it "does nothing if node doesn't exist" do
+      expect { test_class.send(:promote_lru, 0, "nonexistent") }.not_to raise_error
+    end
+  end
+
+  describe "#remove_node (private)" do
+    it "removes a node from the middle of the list" do
+      test_class.send(:insert_lru, 0, "key1")
+      test_class.send(:insert_lru, 0, "key2")
+      test_class.send(:insert_lru, 0, "key3")
+      
+      node = test_class.lru_nodes[0]["key2"]
+      test_class.send(:remove_node, 0, node)
+      
+      expect(test_class.lru_heads[0].key).to eq("key3")
+      expect(test_class.lru_heads[0].next.key).to eq("key1")
+    end
+
+    it "updates head when removing head node" do
+      test_class.send(:insert_lru, 0, "key1")
+      test_class.send(:insert_lru, 0, "key2")
+      
+      node = test_class.lru_heads[0]
+      test_class.send(:remove_node, 0, node)
+      
+      expect(test_class.lru_heads[0].key).to eq("key1")
+    end
+
+    it "updates tail when removing tail node" do
+      test_class.send(:insert_lru, 0, "key1")
+      test_class.send(:insert_lru, 0, "key2")
+      
+      node = test_class.lru_tails[0]
+      test_class.send(:remove_node, 0, node)
+      
+      expect(test_class.lru_tails[0].key).to eq("key2")
+    end
+  end
+
+  describe "#evict_key (private)" do
+    it "removes key from store and LRU list" do
+      test_class.stores[0]["key1"] = { value: "test".b, expires_at: nil }
+      test_class.current_bytes[0] = 100
+      test_class.send(:insert_lru, 0, "key1")
+      
+      test_class.send(:evict_key, 0, "key1")
+      
+      expect(test_class.stores[0]).not_to have_key("key1")
+      expect(test_class.lru_nodes[0]).not_to have_key("key1")
+      expect(test_class.current_bytes[0]).to eq(92) # 100 - "key1".bytesize(4) - "test".bytesize(4)
+    end
+
+    it "does nothing if key doesn't exist" do
+      expect { test_class.send(:evict_key, 0, "nonexistent") }.not_to raise_error
+    end
+
+    it "updates memory counter correctly" do
+      test_class.stores[0]["mykey"] = { value: "myvalue".b, expires_at: nil }
+      test_class.current_bytes[0] = 100
+      
+      test_class.send(:evict_key, 0, "mykey")
+      
+      # 100 - ("mykey".bytesize + "myvalue".bytesize) = 100 - 12 = 88
+      expect(test_class.current_bytes[0]).to eq(88)
+    end
+  end
+end

data/spec/modules/metrics_spec.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+
+RSpec.describe Mudis::Metrics do
+  let(:test_class) do
+    Class.new do
+      extend Mudis::Metrics
+      
+      @metrics = { hits: 5, misses: 3, evictions: 2, rejected: 1 }
+      @metrics_mutex = Mutex.new
+      @buckets = 2
+      @stores = [{ "key1" => {} }, { "key2" => {} }]
+      @current_bytes = [100, 200]
+      @lru_nodes = [{ "key1" => nil }, { "key2" => nil }]
+      
+      class << self
+        attr_accessor :metrics, :metrics_mutex, :buckets, :stores, :current_bytes, :lru_nodes
+        
+        def current_memory_bytes
+          @current_bytes.sum
+        end
+        
+        def least_touched(n)
+          [["key1", 5], ["key2", 10]]
+        end
+      end
+    end
+  end
+
+  describe "#metrics" do
+    it "returns a snapshot of current metrics" do
+      result = test_class.metrics
+      
+      expect(result).to include(
+        hits: 5,
+        misses: 3,
+        evictions: 2,
+        rejected: 1
+      )
+      # total_memory and other derived stats depend on full Mudis context
+    end
+
+    it "includes least_touched keys via delegation" do
+      # This method delegates to least_touched which is defined in main class
+      # In integration tests this works, in isolation we just verify the structure
+      expect(test_class).to respond_to(:metrics)
+    end
+
+    it "includes per-bucket stats via delegation" do
+      # Bucket stats require full context from main class
+      # In integration tests this works, in isolation we just verify the method exists
+      expect(test_class).to respond_to(:metrics)
+    end
+
+    it "is thread-safe" do
+      threads = 10.times.map do
+        Thread.new { test_class.metrics }
+      end
+      
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+  end
+
+  describe "#reset_metrics!" do
+    it "resets all metric counters to zero" do
+      test_class.reset_metrics!
+      
+      expect(test_class.metrics[:hits]).to eq(0)
+      expect(test_class.metrics[:misses]).to eq(0)
+      expect(test_class.metrics[:evictions]).to eq(0)
+      expect(test_class.metrics[:rejected]).to eq(0)
+    end
+
+    it "is thread-safe" do
+      threads = 10.times.map do
+        Thread.new { test_class.reset_metrics! }
+      end
+      
+      expect { threads.each(&:join) }.not_to raise_error
+    end
+  end
+
+  describe "#metric (private)" do
+    it "increments metric counters" do
+      initial_hits = test_class.metrics[:hits]
+      
+      test_class.send(:metric, :hits)
+      
+      expect(test_class.metrics[:hits]).to eq(initial_hits + 1)
+    end
+
+    it "is thread-safe" do
+      test_class.reset_metrics!
+      
+      threads = 100.times.map do
+        Thread.new { test_class.send(:metric, :hits) }
+      end
+      
+      threads.each(&:join)
+      
+      expect(test_class.metrics[:hits]).to eq(100)
+    end
+  end
+end

data/spec/modules/namespace_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+
+RSpec.describe Mudis::Namespace do
+  let(:test_class) do
+    Class.new do
+      extend Mudis::Namespace
+      
+      @buckets = 2
+      @mutexes = Array.new(2) { Mutex.new }
+      @stores = [
+        { "ns1:key1" => {}, "ns1:key2" => {}, "key3" => {} },
+        { "ns2:key1" => {}, "other" => {} }
+      ]
+      @lru_nodes = Array.new(2) { {} }
+      @current_bytes = Array.new(2, 0)
+      
+      class << self
+        attr_accessor :buckets, :mutexes, :stores, :lru_nodes, :current_bytes
+        
+        def all_keys
+          @stores.flat_map(&:keys)
+        end
+        
+        def evict_key(idx, key)
+          @stores[idx].delete(key)
+        end
+      end
+    end
+  end
+
+  describe "#keys" do
+    it "returns all keys for a given namespace" do
+      keys = test_class.keys(namespace: "ns1")
+      
+      expect(keys).to contain_exactly("key1", "key2")
+    end
+
+    it "returns empty array if no keys exist for namespace" do
+      keys = test_class.keys(namespace: "nonexistent")
+      
+      expect(keys).to eq([])
+    end
+
+    it "raises error if namespace is nil" do
+      expect { test_class.keys(namespace: nil) }.to raise_error(ArgumentError, "namespace is required")
+    end
+
+    it "strips namespace prefix from returned keys" do
+      keys = test_class.keys(namespace: "ns2")
+      
+      expect(keys).to eq(["key1"])
+      expect(keys).not_to include("ns2:key1")
+    end
+  end
+
+  describe "#clear_namespace" do
+    it "deletes all keys in a given namespace" do
+      test_class.clear_namespace(namespace: "ns1")
+      
+      expect(test_class.stores[0]).not_to have_key("ns1:key1")
+      expect(test_class.stores[0]).not_to have_key("ns1:key2")
+      expect(test_class.stores[0]).to have_key("key3") # non-namespaced key remains
+    end
+
+    it "does nothing if namespace has no keys" do
+      expect { test_class.clear_namespace(namespace: "nonexistent") }.not_to raise_error
+    end
+
+    it "raises error if namespace is nil" do
+      expect { test_class.clear_namespace(namespace: nil) }.to raise_error(ArgumentError, "namespace is required")
+    end
+
+    it "only deletes keys with exact namespace prefix" do
+      test_class.stores[0]["ns1_similar"] = {}
+      
+      test_class.clear_namespace(namespace: "ns1")
+      
+      expect(test_class.stores[0]).to have_key("ns1_similar")
+    end
+  end
+
+  describe "#with_namespace" do
+    it "sets thread-local namespace for the block" do
+      test_class.with_namespace("test_ns") do
+        expect(Thread.current[:mudis_namespace]).to eq("test_ns")
+      end
+    end
+
+    it "restores previous namespace after block" do
+      Thread.current[:mudis_namespace] = "original"
+      
+      test_class.with_namespace("temporary") do
+        # inside block
+      end
+      
+      expect(Thread.current[:mudis_namespace]).to eq("original")
+    end
+
+    it "restores namespace even if block raises error" do
+      Thread.current[:mudis_namespace] = "original"
+      
+      expect do
+        test_class.with_namespace("temporary") do
+          raise "test error"
+        end
+      end.to raise_error("test error")
+      
+      expect(Thread.current[:mudis_namespace]).to eq("original")
+    end
+
+    it "returns the block's return value" do
+      result = test_class.with_namespace("test") do
+        "block_result"
+      end
+      
+      expect(result).to eq("block_result")
+    end
+  end
+
+  describe "#namespaced_key (private)" do
+    it "prefixes key with namespace" do
+      result = test_class.send(:namespaced_key, "mykey", "mynamespace")
+      
+      expect(result).to eq("mynamespace:mykey")
+    end
+
+    it "returns unprefixed key when namespace is nil" do
+      Thread.current[:mudis_namespace] = nil
+      
+      result = test_class.send(:namespaced_key, "mykey", nil)
+      
+      expect(result).to eq("mykey")
+    end
+
+    it "uses thread-local namespace when explicit namespace is nil" do
+      Thread.current[:mudis_namespace] = "thread_ns"
+      
+      result = test_class.send(:namespaced_key, "mykey", nil)
+      
+      expect(result).to eq("thread_ns:mykey")
+    ensure
+      Thread.current[:mudis_namespace] = nil
+    end
+
+    it "prefers explicit namespace over thread-local" do
+      Thread.current[:mudis_namespace] = "thread_ns"
+      
+      result = test_class.send(:namespaced_key, "mykey", "explicit_ns")
+      
+      expect(result).to eq("explicit_ns:mykey")
+    ensure
+      Thread.current[:mudis_namespace] = nil
+    end
+  end
+end

data/spec/modules/persistence_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require_relative "../spec_helper"
+
+RSpec.describe Mudis::Persistence do
+  let(:test_class) do
+    Class.new do
+      extend Mudis::Persistence
+      
+      @persistence_enabled = true
+      @persistence_path = "tmp/test_persistence.json"
+      @persistence_format = :json
+      @persistence_safe_write = true
+      @buckets = 2
+      @mutexes = Array.new(2) { Mutex.new }
+      @stores = Array.new(2) { {} }
+      @lru_nodes = Array.new(2) { {} }
+      @lru_heads = Array.new(2) { nil }
+      @lru_tails = Array.new(2) { nil }
+      @current_bytes = Array.new(2, 0)
+      @compress = false
+      @serializer = JSON
+      
+      class << self
+        attr_accessor :persistence_enabled, :persistence_path, :persistence_format, 
+                      :persistence_safe_write, :buckets, :mutexes, :stores, :compress, :serializer
+        
+        def decompress_and_deserialize(raw)
+          JSON.load(raw)
+        end
+        
+        def write(key, value, expires_in: nil)
+          # Stub write method
+          @stores[0][key] = { value: JSON.dump(value), expires_at: nil, created_at: Time.now }
+        end
+      end
+    end
+  end
+
+  after do
+    File.unlink(test_class.persistence_path) if File.exist?(test_class.persistence_path)
+  end
+
+  describe "#save_snapshot!" do
+    it "saves cache data to disk" do
+      test_class.stores[0]["key1"] = { 
+        value: JSON.dump("value1"), 
+        expires_at: nil, 
+        created_at: Time.now 
+      }
+      
+      test_class.save_snapshot!
+      
+      expect(File.exist?(test_class.persistence_path)).to be true
+    end
+
+    it "handles errors gracefully" do
+      allow(test_class).to receive(:snapshot_dump).and_raise("Test error")
+      
+      expect { test_class.save_snapshot! }.to output(/Failed to save snapshot/).to_stderr
+    end
+
+    it "does nothing when persistence is disabled" do
+      test_class.persistence_enabled = false
+      
+      test_class.save_snapshot!
+      
+      expect(File.exist?(test_class.persistence_path)).to be false
+    end
+  end
+
+  describe "#load_snapshot!" do
+    it "loads cache data from disk" do
+      data = [{ key: "test_key", value: "test_value", expires_in: nil }]
+      File.write(test_class.persistence_path, JSON.dump(data))
+      
+      expect(test_class).to receive(:write).with("test_key", "test_value", expires_in: nil)
+      
+      test_class.load_snapshot!
+    end
+
+    it "handles missing file gracefully" do
+      expect { test_class.load_snapshot! }.not_to raise_error
+    end
+
+    it "handles errors gracefully" do
+      File.write(test_class.persistence_path, "invalid json")
+      
+      expect { test_class.load_snapshot! }.to output(/Failed to load snapshot/).to_stderr
+    end
+
+    it "does nothing when persistence is disabled" do
+      test_class.persistence_enabled = false
+      File.write(test_class.persistence_path, JSON.dump([]))
+      
+      expect(test_class).not_to receive(:write)
+      
+      test_class.load_snapshot!
+    end
+  end
+
+  describe "#install_persistence_hook!" do
+    it "installs at_exit hook" do
+      expect(test_class).to receive(:at_exit)
+      
+      test_class.install_persistence_hook!
+    end
+
+    it "only installs hook once" do
+      test_class.install_persistence_hook!
+      
+      expect(test_class).not_to receive(:at_exit)
+      
+      test_class.install_persistence_hook!
+    end
+
+    it "does nothing when persistence is disabled" do
+      test_class.persistence_enabled = false
+      
+      expect(test_class).not_to receive(:at_exit)
+      
+      test_class.install_persistence_hook!
+    end
+  end
+end