mudis 0.9.1 → 0.9.4

data/spec/mudis_client_spec.rb

@@ -99,32 +99,93 @@ RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
     end
   end
 
-  describe "#reset_metrics!" do
-    it "sends a reset_metrics command" do
-      payload = { cmd: "reset_metrics" }
-      response = { ok: true, value: nil }.to_json
+  describe "#inspect" do
+    it "sends an inspect command and returns metadata" do
+      payload = { cmd: "inspect", key: "test_key", namespace: nil }
+      response = { ok: true, value: { key: "test_key", size_bytes: 10 } }.to_json
 
       expect(mock_socket).to receive(:puts).with(payload.to_json)
       expect(mock_socket).to receive(:gets).and_return(response)
 
-      expect(client.reset_metrics!).to be_nil
+      expect(client.inspect("test_key")).to eq({ key: "test_key", size_bytes: 10 })
     end
   end
 
-  describe "#reset!" do
-    it "sends a reset command" do
-      payload = { cmd: "reset" }
+  describe "#keys" do
+    it "sends a keys command and returns keys" do
+      payload = { cmd: "keys", namespace: "ns" }
+      response = { ok: true, value: ["a", "b"] }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.keys(namespace: "ns")).to eq(["a", "b"])
+    end
+  end
+
+  describe "#clear_namespace" do
+    it "sends a clear_namespace command" do
+      payload = { cmd: "clear_namespace", namespace: "ns" }
       response = { ok: true, value: nil }.to_json
 
       expect(mock_socket).to receive(:puts).with(payload.to_json)
       expect(mock_socket).to receive(:gets).and_return(response)
 
-      expect(client.reset!).to be_nil
+      expect(client.clear_namespace(namespace: "ns")).to be_nil
+    end
+  end
+
+  describe "#least_touched" do
+    it "sends a least_touched command" do
+      payload = { cmd: "least_touched", limit: 5 }
+      response = { ok: true, value: [["a", 0], ["b", 1]] }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.least_touched(5)).to eq([["a", 0], ["b", 1]])
+    end
+  end
+
+  describe "#all_keys" do
+    it "sends an all_keys command" do
+      payload = { cmd: "all_keys" }
+      response = { ok: true, value: ["k1"] }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.all_keys).to eq(["k1"])
+    end
+  end
+
+  describe "#current_memory_bytes" do
+    it "sends a current_memory_bytes command" do
+      payload = { cmd: "current_memory_bytes" }
+      response = { ok: true, value: 123 }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.current_memory_bytes).to eq(123)
+    end
+  end
+
+  describe "#max_memory_bytes" do
+    it "sends a max_memory_bytes command" do
+      payload = { cmd: "max_memory_bytes" }
+      response = { ok: true, value: 456 }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.max_memory_bytes).to eq(456)
     end
   end
 
   describe "error handling" do
     it "warns when the socket is missing" do
+      allow(MudisIPCConfig).to receive(:retries).and_return(1)
       if MudisIPCConfig.use_tcp?
         allow(TCPSocket).to receive(:new).and_raise(Errno::ECONNREFUSED)
       else
@@ -143,5 +204,18 @@ RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
 
       expect { client.read("test_key") }.to raise_error("Something went wrong")
     end
+
+    it "retries on timeout and then warns" do
+      allow(MudisIPCConfig).to receive(:retries).and_return(1)
+      allow(MudisIPCConfig).to receive(:timeout).and_return(0.01)
+
+      if MudisIPCConfig.use_tcp?
+        allow(TCPSocket).to receive(:new).and_raise(Timeout::Error)
+      else
+        allow(UNIXSocket).to receive(:open).and_raise(Timeout::Error)
+      end
+
+      expect { client.read("test_key") }.to output(/Cannot connect/).to_stderr
+    end
   end
 end

data/spec/mudis_server_spec.rb

@@ -13,8 +13,6 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
     next
   end
 
-  let(:socket_path) { MudisIPCConfig::SOCKET_PATH }
-
   before(:all) do
     # Start the server once for all tests
     Thread.new { MudisServer.start! }
@@ -27,12 +25,18 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
     allow(Mudis).to receive(:delete)
     allow(Mudis).to receive(:exists?).and_return(true)
     allow(Mudis).to receive(:fetch).and_return("mock_fetched_value")
+    allow(Mudis).to receive(:inspect).and_return({ key: "test_key", size_bytes: 10 })
+    allow(Mudis).to receive(:keys).and_return(["a", "b"])
+    allow(Mudis).to receive(:clear_namespace)
+    allow(Mudis).to receive(:least_touched).and_return([["a", 0]])
+    allow(Mudis).to receive(:all_keys).and_return(["k1"])
+    allow(Mudis).to receive(:current_memory_bytes).and_return(123)
+    allow(Mudis).to receive(:max_memory_bytes).and_return(456)
     allow(Mudis).to receive(:metrics).and_return({ reads: 1, writes: 1 })
-    allow(Mudis).to receive(:reset_metrics!)
-    allow(Mudis).to receive(:reset!)
   end
 
-  after do
+  after(:all) do
+    socket_path = MudisIPCConfig::SOCKET_PATH
     File.unlink(socket_path) if File.exist?(socket_path) && !MudisIPCConfig.use_tcp?
   end
 
@@ -43,7 +47,7 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
         JSON.parse(sock.gets, symbolize_names: true)
       end
     else
-      UNIXSocket.open(socket_path) do |sock|
+      UNIXSocket.open(MudisIPCConfig::SOCKET_PATH) do |sock|
         sock.puts(JSON.dump(request))
         JSON.parse(sock.gets, symbolize_names: true)
       end
@@ -81,22 +85,52 @@ RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
     expect(Mudis).to have_received(:fetch).with("test_key", expires_in: 60, namespace: "test_ns")
   end
 
-  it "handles the 'metrics' command" do
-    response = send_request({ cmd: "metrics" })
-    expect(response).to eq({ ok: true, value: { reads: 1, writes: 1 } })
-    expect(Mudis).to have_received(:metrics)
+  it "handles the 'inspect' command" do
+    response = send_request({ cmd: "inspect", key: "test_key", namespace: "test_ns" })
+    expect(response).to eq({ ok: true, value: { key: "test_key", size_bytes: 10 } })
+    expect(Mudis).to have_received(:inspect).with("test_key", namespace: "test_ns")
   end
 
-  it "handles the 'reset_metrics' command" do
-    response = send_request({ cmd: "reset_metrics" })
-    expect(response).to eq({ ok: true, value: nil })
-    expect(Mudis).to have_received(:reset_metrics!)
+  it "handles the 'keys' command" do
+    response = send_request({ cmd: "keys", namespace: "test_ns" })
+    expect(response).to eq({ ok: true, value: ["a", "b"] })
+    expect(Mudis).to have_received(:keys).with(namespace: "test_ns")
   end
 
-  it "handles the 'reset' command" do
-    response = send_request({ cmd: "reset" })
+  it "handles the 'clear_namespace' command" do
+    response = send_request({ cmd: "clear_namespace", namespace: "test_ns" })
     expect(response).to eq({ ok: true, value: nil })
-    expect(Mudis).to have_received(:reset!)
+    expect(Mudis).to have_received(:clear_namespace).with(namespace: "test_ns")
+  end
+
+  it "handles the 'least_touched' command" do
+    response = send_request({ cmd: "least_touched", limit: 5 })
+    expect(response).to eq({ ok: true, value: [["a", 0]] })
+    expect(Mudis).to have_received(:least_touched).with(5)
+  end
+
+  it "handles the 'all_keys' command" do
+    response = send_request({ cmd: "all_keys" })
+    expect(response).to eq({ ok: true, value: ["k1"] })
+    expect(Mudis).to have_received(:all_keys)
+  end
+
+  it "handles the 'current_memory_bytes' command" do
+    response = send_request({ cmd: "current_memory_bytes" })
+    expect(response).to eq({ ok: true, value: 123 })
+    expect(Mudis).to have_received(:current_memory_bytes)
+  end
+
+  it "handles the 'max_memory_bytes' command" do
+    response = send_request({ cmd: "max_memory_bytes" })
+    expect(response).to eq({ ok: true, value: 456 })
+    expect(Mudis).to have_received(:max_memory_bytes)
+  end
+
+  it "handles the 'metrics' command" do
+    response = send_request({ cmd: "metrics" })
+    expect(response).to eq({ ok: true, value: { reads: 1, writes: 1 } })
+    expect(Mudis).to have_received(:metrics)
   end
 
   it "handles unknown commands" do

data/spec/mudis_spec.rb

@@ -55,6 +55,19 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
       Mudis.update("counter") { |v| v + 1 }
       expect(Mudis.read("counter")).to eq(6)
     end
+
+    it "refreshes TTL based on original duration" do
+      Mudis.write("ttl_key", "v", expires_in: 2)
+      meta_before = Mudis.inspect("ttl_key")
+      original_ttl = meta_before[:expires_at] - meta_before[:created_at]
+
+      sleep 1
+      Mudis.update("ttl_key") { |v| v }
+      meta_after = Mudis.inspect("ttl_key")
+
+      expect(meta_after[:created_at]).to be > meta_before[:created_at]
+      expect(meta_after[:expires_at]).to be_within(0.5).of(Time.now + original_ttl)
+    end
   end
 
   describe ".fetch" do
@@ -76,6 +89,30 @@ RSpec.describe Mudis do # rubocop:disable Metrics/BlockLength
       result = Mudis.fetch("k", force: true) { 200 } # fix
       expect(result).to eq(200)
     end
+
+    it "executes the block once with singleflight: true" do
+      Mudis.delete("sf")
+      count = 0
+      count_mutex = Mutex.new
+      results = []
+      results_mutex = Mutex.new
+
+      threads = 5.times.map do
+        Thread.new do
+          value = Mudis.fetch("sf", singleflight: true) do
+            count_mutex.synchronize { count += 1 }
+            sleep 0.05
+            "v"
+          end
+          results_mutex.synchronize { results << value }
+        end
+      end
+
+      threads.each(&:join)
+      expect(count).to eq(1)
+      expect(results).to all(eq("v"))
+      expect(Mudis.read("sf")).to eq("v")
+    end
   end
 
   describe ".clear" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mudis
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.9.4
 platform: ruby
 authors:
 - kiebor81
@@ -60,6 +60,7 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - sig/mudis.rbs
+- sig/mudis_bound.rbs
 - sig/mudis_client.rbs
 - sig/mudis_config.rbs
 - sig/mudis_expiry.rbs
@@ -72,6 +73,7 @@ extra_rdoc_files:
 files:
 - README.md
 - lib/mudis.rb
+- lib/mudis/bound.rb
 - lib/mudis/expiry.rb
 - lib/mudis/lru.rb
 - lib/mudis/metrics.rb
@@ -84,6 +86,7 @@ files:
 - lib/mudis_proxy.rb
 - lib/mudis_server.rb
 - sig/mudis.rbs
+- sig/mudis_bound.rbs
 - sig/mudis_client.rbs
 - sig/mudis_config.rbs
 - sig/mudis_expiry.rbs
@@ -94,6 +97,7 @@ files:
 - sig/mudis_persistence.rbs
 - sig/mudis_server.rbs
 - spec/api_compatibility_spec.rb
+- spec/bound_spec.rb
 - spec/eviction_spec.rb
 - spec/guardrails_spec.rb
 - spec/memory_guard_spec.rb
@@ -121,7 +125,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -135,6 +139,7 @@ summary: A fast in-memory, thread-safe and high performance Ruby LRU cache with
   and auto-expiry.
 test_files:
 - spec/api_compatibility_spec.rb
+- spec/bound_spec.rb
 - spec/eviction_spec.rb
 - spec/guardrails_spec.rb
 - spec/memory_guard_spec.rb