mudis 0.8.1 → 0.9.0

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

data/spec/mudis_client_spec.rb

@@ -3,8 +3,9 @@
 require_relative "spec_helper"
 
 RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
-  let(:socket_path) { "/tmp/mudis.sock" }
-  let(:mock_socket) { instance_double(UNIXSocket) }
+  let(:socket_path) { MudisIPCConfig::SOCKET_PATH }
+  let(:socket_class) { MudisIPCConfig.use_tcp? ? TCPSocket : UNIXSocket }
+  let(:mock_socket) { instance_double(socket_class) }
   let(:client) { MudisClient.new }
 
   around do |example|
@@ -14,7 +15,12 @@ RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
   end
 
   before do
-    allow(UNIXSocket).to receive(:open).and_yield(mock_socket)
+    if MudisIPCConfig.use_tcp?
+      allow(TCPSocket).to receive(:new).and_return(mock_socket)
+    else
+      allow(UNIXSocket).to receive(:open).and_yield(mock_socket)
+    end
+    allow(mock_socket).to receive(:close)
   end
 
   describe "#read" do
@@ -119,9 +125,13 @@ RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
 
   describe "error handling" do
     it "warns when the socket is missing" do
-      allow(UNIXSocket).to receive(:open).and_raise(Errno::ENOENT)
+      if MudisIPCConfig.use_tcp?
+        allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED)
+      else
+        allow(UNIXSocket).to receive(:open).and_raise(Errno::ENOENT)
+      end
 
-      expect { client.read("test_key") }.to output(/Socket missing/).to_stderr
+      expect { client.read("test_key") }.to output(/Cannot connect/).to_stderr
       expect(client.read("test_key")).to be_nil
     end
 

data/spec/mudis_server_spec.rb

@@ -6,13 +6,15 @@ require "json"
 require_relative "spec_helper"
 
 RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
+  let(:socket_path) { MudisIPCConfig::SOCKET_PATH }
+
   before(:all) do
-    skip "UNIX sockets not supported on Windows" if Gem.win_platform?
+    # Start the server once for all tests
+    Thread.new { MudisServer.start! }
+    sleep 0.2 # Allow the server to start
   end
 
-  let(:socket_path) { MudisServer::SOCKET_PATH }
-
-  before do
+  before(:each) do
     allow(Mudis).to receive(:read).and_return("mock_value")
     allow(Mudis).to receive(:write)
     allow(Mudis).to receive(:delete)
@@ -21,20 +23,23 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
     allow(Mudis).to receive(:metrics).and_return({ reads: 1, writes: 1 })
     allow(Mudis).to receive(:reset_metrics!)
     allow(Mudis).to receive(:reset!)
-
-    # Start the server in a separate thread
-    Thread.new { MudisServer.start! }
-    sleep 0.1 # Allow the server to start
   end
 
   after do
-    File.unlink(socket_path) if File.exist?(socket_path)
+    File.unlink(socket_path) if File.exist?(socket_path) && !MudisIPCConfig.use_tcp?
   end
 
   def send_request(request)
-    UNIXSocket.open(socket_path) do |sock|
-      sock.puts(JSON.dump(request))
-      JSON.parse(sock.gets, symbolize_names: true)
+    if MudisIPCConfig.use_tcp?
+      TCPSocket.open(MudisIPCConfig::TCP_HOST, MudisIPCConfig::TCP_PORT) do |sock|
+        sock.puts(JSON.dump(request))
+        JSON.parse(sock.gets, symbolize_names: true)
+      end
+    else
+      UNIXSocket.open(socket_path) do |sock|
+        sock.puts(JSON.dump(request))
+        JSON.parse(sock.gets, symbolize_names: true)
+      end
     end
   end
 
@@ -46,13 +51,13 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
 
   it "handles the 'write' command" do
     response = send_request({ cmd: "write", key: "test_key", value: "test_value", ttl: 60, namespace: "test_ns" })
-    expect(response).to eq({ ok: true })
+    expect(response).to eq({ ok: true, value: nil })
     expect(Mudis).to have_received(:write).with("test_key", "test_value", expires_in: 60, namespace: "test_ns")
   end
 
   it "handles the 'delete' command" do
     response = send_request({ cmd: "delete", key: "test_key", namespace: "test_ns" })
-    expect(response).to eq({ ok: true })
+    expect(response).to eq({ ok: true, value: nil })
     expect(Mudis).to have_received(:delete).with("test_key", namespace: "test_ns")
   end
 
@@ -77,18 +82,19 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
 
   it "handles the 'reset_metrics' command" do
     response = send_request({ cmd: "reset_metrics" })
-    expect(response).to eq({ ok: true })
+    expect(response).to eq({ ok: true, value: nil })
     expect(Mudis).to have_received(:reset_metrics!)
   end
 
   it "handles the 'reset' command" do
     response = send_request({ cmd: "reset" })
-    expect(response).to eq({ ok: true })
+    expect(response).to eq({ ok: true, value: nil })
     expect(Mudis).to have_received(:reset!)
   end
 
   it "handles unknown commands" do
     response = send_request({ cmd: "unknown_command" })
-    expect(response).to eq({ ok: false, error: "unknown command: unknown_command" })
+    expect(response[:ok]).to be false
+    expect(response[:error]).to match(/unknown command/i)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mudis
 version: !ruby/object:Gem::Version
-  version: 0.8.1
+  version: 0.9.0
 platform: ruby
 authors:
 - kiebor81
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-10-26 00:00:00.000000000 Z
+date: 2025-12-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: climate_control
@@ -38,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.22'
 description: Mudis is a fast, thread-safe, in-memory, sharded LRU cache for Ruby applications.
   Inspired by Redis, it provides value serialization, optional compression, per-key
   expiry, and metric tracking in a lightweight, dependency-free package.
@@ -48,23 +62,47 @@ extra_rdoc_files:
 - sig/mudis.rbs
 - sig/mudis_client.rbs
 - sig/mudis_config.rbs
+- sig/mudis_expiry.rbs
+- sig/mudis_ipc_config.rbs
+- sig/mudis_lru.rbs
+- sig/mudis_metrics.rbs
+- sig/mudis_namespace.rbs
+- sig/mudis_persistence.rbs
 - sig/mudis_server.rbs
 files:
 - README.md
 - lib/mudis.rb
+- lib/mudis/expiry.rb
+- lib/mudis/lru.rb
+- lib/mudis/metrics.rb
+- lib/mudis/namespace.rb
+- lib/mudis/persistence.rb
 - lib/mudis/version.rb
 - lib/mudis_client.rb
 - lib/mudis_config.rb
+- lib/mudis_ipc_config.rb
 - lib/mudis_proxy.rb
 - lib/mudis_server.rb
 - sig/mudis.rbs
 - sig/mudis_client.rbs
 - sig/mudis_config.rbs
+- sig/mudis_expiry.rbs
+- sig/mudis_ipc_config.rbs
+- sig/mudis_lru.rbs
+- sig/mudis_metrics.rbs
+- sig/mudis_namespace.rbs
+- sig/mudis_persistence.rbs
 - sig/mudis_server.rbs
+- spec/api_compatibility_spec.rb
 - spec/eviction_spec.rb
 - spec/guardrails_spec.rb
 - spec/memory_guard_spec.rb
 - spec/metrics_spec.rb
+- spec/modules/expiry_spec.rb
+- spec/modules/lru_spec.rb
+- spec/modules/metrics_spec.rb
+- spec/modules/namespace_spec.rb
+- spec/modules/persistence_spec.rb
 - spec/mudis_client_spec.rb
 - spec/mudis_server_spec.rb
 - spec/mudis_spec.rb
@@ -96,10 +134,16 @@ specification_version: 4
 summary: A fast in-memory, thread-safe and high performance Ruby LRU cache with compression
   and auto-expiry.
 test_files:
+- spec/api_compatibility_spec.rb
 - spec/eviction_spec.rb
 - spec/guardrails_spec.rb
 - spec/memory_guard_spec.rb
 - spec/metrics_spec.rb
+- spec/modules/expiry_spec.rb
+- spec/modules/lru_spec.rb
+- spec/modules/metrics_spec.rb
+- spec/modules/namespace_spec.rb
+- spec/modules/persistence_spec.rb
 - spec/mudis_client_spec.rb
 - spec/mudis_server_spec.rb
 - spec/mudis_spec.rb