mudis 0.7.0 → 0.7.2

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/mudis_client_spec.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+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(:client) { MudisClient.new }
+
+  around do |example|
+    ClimateControl.modify("SOCKET_PATH" => socket_path) do
+      example.run
+    end
+  end
+
+  before do
+    allow(UNIXSocket).to receive(:open).and_yield(mock_socket)
+  end
+
+  describe "#read" do
+    it "sends a read command and returns the value" do
+      payload = { cmd: "read", key: "test_key", namespace: nil }
+      response = { ok: true, value: "test_value" }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.read("test_key")).to eq("test_value")
+    end
+  end
+
+  describe "#write" do
+    it "sends a write command and returns the value" do
+      payload = { cmd: "write", key: "test_key", value: "test_value", ttl: nil, namespace: nil }
+      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.write("test_key", "test_value")).to be_nil
+    end
+  end
+
+  describe "#delete" do
+    it "sends a delete command and returns the value" do
+      payload = { cmd: "delete", key: "test_key", namespace: nil }
+      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.delete("test_key")).to be_nil
+    end
+  end
+
+  describe "#exists?" do
+    it "sends an exists command and returns true" do
+      payload = { cmd: "exists", key: "test_key", namespace: nil }
+      response = { ok: true, value: true }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.exists?("test_key")).to eq(true)
+    end
+  end
+
+  describe "#fetch" do
+    it "fetches an existing value or writes a new one" do
+      read_response = { ok: true, value: nil }.to_json
+      write_payload = { cmd: "write", key: "test_key", value: "new_value", ttl: nil, namespace: nil }
+      write_response = { ok: true, value: nil }.to_json
+
+      expect(mock_socket).to receive(:puts).with({ cmd: "read", key: "test_key", namespace: nil }.to_json)
+      expect(mock_socket).to receive(:gets).and_return(read_response)
+      expect(mock_socket).to receive(:puts).with(write_payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(write_response)
+
+      result = client.fetch("test_key") { "new_value" } # rubocop:disable Style/RedundantFetchBlock
+      expect(result).to eq("new_value")
+    end
+  end
+
+  describe "#metrics" do
+    it "sends a metrics command and returns the metrics" do
+      payload = { cmd: "metrics" }
+      response = { ok: true, value: { reads: 10, writes: 5 } }.to_json
+
+      expect(mock_socket).to receive(:puts).with(payload.to_json)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect(client.metrics).to eq({ reads: 10, writes: 5 })
+    end
+  end
+
+  describe "#reset_metrics!" do
+    it "sends a reset_metrics command" do
+      payload = { cmd: "reset_metrics" }
+      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_metrics!).to be_nil
+    end
+  end
+
+  describe "#reset!" do
+    it "sends a reset command" do
+      payload = { cmd: "reset" }
+      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
+    end
+  end
+
+  describe "error handling" do
+    it "warns when the socket is missing" do
+      allow(UNIXSocket).to receive(:open).and_raise(Errno::ENOENT)
+
+      expect { client.read("test_key") }.to output(/Socket missing/).to_stderr
+      expect(client.read("test_key")).to be_nil
+    end
+
+    it "raises an error when the server returns an error" do
+      response = { ok: false, error: "Something went wrong" }.to_json
+
+      expect(mock_socket).to receive(:puts)
+      expect(mock_socket).to receive(:gets).and_return(response)
+
+      expect { client.read("test_key") }.to raise_error("Something went wrong")
+    end
+  end
+end

data/spec/mudis_server_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+
+require_relative "spec_helper"
+
+RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
+  let(:socket_path) { MudisServer::SOCKET_PATH }
+
+  before do
+    allow(Mudis).to receive(:read).and_return("mock_value")
+    allow(Mudis).to receive(:write)
+    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(: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)
+  end
+
+  def send_request(request)
+    UNIXSocket.open(socket_path) do |sock|
+      sock.puts(JSON.dump(request))
+      JSON.parse(sock.gets, symbolize_names: true)
+    end
+  end
+
+  it "handles the 'read' command" do
+    response = send_request({ cmd: "read", key: "test_key", namespace: "test_ns" })
+    expect(response).to eq({ ok: true, value: "mock_value" })
+    expect(Mudis).to have_received(:read).with("test_key", namespace: "test_ns")
+  end
+
+  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(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(Mudis).to have_received(:delete).with("test_key", namespace: "test_ns")
+  end
+
+  it "handles the 'exists' command" do
+    response = send_request({ cmd: "exists", key: "test_key", namespace: "test_ns" })
+    expect(response).to eq({ ok: true, value: true })
+    expect(Mudis).to have_received(:exists?).with("test_key", namespace: "test_ns")
+  end
+
+  it "handles the 'fetch' command" do
+    response = send_request({ cmd: "fetch", key: "test_key", ttl: 60, namespace: "test_ns",
+                              fallback: "fallback_value" })
+    expect(response).to eq({ ok: true, value: "mock_fetched_value" })
+    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)
+  end
+
+  it "handles the 'reset_metrics' command" do
+    response = send_request({ cmd: "reset_metrics" })
+    expect(response).to eq({ ok: true })
+    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(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" })
+  end
+end