mudis 0.9.0 → 0.9.4

data/sig/mudis_server.rbs

@@ -7,11 +7,11 @@ class MudisServer
 
   def self.start_unix_server!: () -> void
 
-  def self.accept_connections: (server: (TCPServer | UNIXServer)) -> void
+  def self.accept_connections: (server: (TCPServer | UNIXServer)) -> Thread
 
   def self.handle_client: (socket: (TCPSocket | UNIXSocket)) -> void
 
-  def self.process_request: (req: Hash[String, untyped]) -> Hash[Symbol, untyped]
+  def self.process_request: (req: Hash[Symbol, untyped]) -> untyped
 
   def self.write_response: (socket: (TCPSocket | UNIXSocket), payload: Hash[Symbol, untyped]) -> void
-end
+end

data/spec/api_compatibility_spec.rb

@@ -29,6 +29,8 @@ RSpec.describe "Mudis Public API" do
       expect(Mudis).to respond_to(:max_value_bytes=)
       expect(Mudis).to respond_to(:hard_memory_limit)
       expect(Mudis).to respond_to(:hard_memory_limit=)
+      expect(Mudis).to respond_to(:eviction_threshold)
+      expect(Mudis).to respond_to(:eviction_threshold=)
       expect(Mudis).to respond_to(:max_ttl)
       expect(Mudis).to respond_to(:max_ttl=)
       expect(Mudis).to respond_to(:default_ttl)
@@ -77,6 +79,7 @@ RSpec.describe "Mudis Public API" do
       expect(Mudis.method(:fetch).parameters).to include([:key, :expires_in])
       expect(Mudis.method(:fetch).parameters).to include([:key, :force])
       expect(Mudis.method(:fetch).parameters).to include([:key, :namespace])
+      expect(Mudis.method(:fetch).parameters).to include([:key, :singleflight])
     end
 
     it "verifies LRUNode class is still accessible" do

data/spec/bound_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe Mudis::Bound do
+  before do
+    Mudis.reset!
+    Mudis.serializer = JSON
+    Mudis.compress = false
+  end
+
+  it "scopes reads and writes to the bound namespace" do
+    bound = Mudis.bind(namespace: "caller")
+    bound.write("k", "v")
+
+    expect(Mudis.read("k")).to be_nil
+    expect(bound.read("k")).to eq("v")
+    expect(Mudis.read("k", namespace: "caller")).to eq("v")
+  end
+
+  it "applies default_ttl and max_ttl within the scope" do
+    bound = Mudis.bind(namespace: "caller", default_ttl: 120, max_ttl: 30)
+    bound.write("k", "v")
+
+    meta = bound.inspect("k")
+    expect(meta[:expires_at]).not_to be_nil
+    expect(meta[:expires_at]).to be_within(5).of(Time.now + 30)
+  end
+
+  it "rejects values that exceed max_value_bytes" do
+    bound = Mudis.bind(namespace: "caller", max_value_bytes: 10)
+    bound.write("k", "a" * 20)
+
+    expect(bound.read("k")).to be_nil
+  end
+
+  it "rejects updates that exceed max_value_bytes" do
+    bound = Mudis.bind(namespace: "caller", max_value_bytes: 10)
+    bound.write("k", "ok")
+
+    bound.update("k") { "a" * 20 }
+    expect(bound.read("k")).to eq("ok")
+  end
+
+  it "fetches within the bound namespace" do
+    bound = Mudis.bind(namespace: "caller")
+    value = bound.fetch("k") { "v" }
+
+    expect(value).to eq("v")
+    expect(Mudis.read("k")).to be_nil
+    expect(bound.read("k")).to eq("v")
+  end
+
+  it "executes the block once with singleflight: true" do
+    bound = Mudis.bind(namespace: "caller")
+    count = 0
+    count_mutex = Mutex.new
+    results = []
+    results_mutex = Mutex.new
+
+    threads = 5.times.map do
+      Thread.new do
+        value = bound.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(bound.read("sf")).to eq("v")
+  end
+
+  it "exposes metrics scoped to the bound namespace" do
+    bound = Mudis.bind(namespace: "caller")
+    bound.write("k", "v")
+    bound.read("k")
+    bound.read("missing")
+
+    metrics = bound.metrics
+    expect(metrics[:namespace]).to eq("caller")
+    expect(metrics[:hits]).to eq(1)
+    expect(metrics[:misses]).to eq(1)
+  end
+end

data/spec/guardrails_spec.rb

@@ -134,5 +134,19 @@ RSpec.describe "Mudis Configuration Guardrails" do # rubocop:disable Metrics/Blo
         end
       end.to raise_error(ArgumentError, /max_value_bytes cannot exceed max_bytes/)
     end
+
+    it "raises if eviction_threshold is <= 0 or > 1" do
+      expect do
+        Mudis.configure do |c|
+          c.eviction_threshold = 0
+        end
+      end.to raise_error(ArgumentError, /eviction_threshold must be > 0 and <= 1/)
+
+      expect do
+        Mudis.configure do |c|
+          c.eviction_threshold = 1.5
+        end
+      end.to raise_error(ArgumentError, /eviction_threshold must be > 0 and <= 1/)
+    end
   end
 end

data/spec/memory_guard_spec.rb

@@ -30,4 +30,13 @@ RSpec.describe "Mudis Memory Guardrails" do
     expect(Mudis.read("b")).to be_nil
     expect(Mudis.metrics[:rejected]).to be > 0
   end
+
+  it "rejects updates that exceed max memory" do
+    Mudis.write("a", "a" * 10)
+    expect(Mudis.read("a")).to eq("a" * 10)
+
+    Mudis.update("a") { "b" * 200 }
+    expect(Mudis.read("a")).to eq("a" * 10)
+    expect(Mudis.metrics[:rejected]).to be > 0
+  end
 end

data/spec/metrics_spec.rb

@@ -31,4 +31,25 @@ RSpec.describe "Mudis Metrics" do # rubocop:disable Metrics/BlockLength
     expect(Mudis.metrics[:misses]).to eq(0)
     expect(Mudis.read("metrics_key")).to eq("value")
   end
+
+  it "tracks metrics per namespace" do
+    Mudis.write("k1", "v1", namespace: "ns1")
+    Mudis.write("k2", "v2", namespace: "ns2")
+
+    Mudis.read("k1", namespace: "ns1")
+    Mudis.read("k1", namespace: "ns1")
+    Mudis.read("missing", namespace: "ns1")
+    Mudis.read("k2", namespace: "ns2")
+
+    ns1 = Mudis.metrics(namespace: "ns1")
+    ns2 = Mudis.metrics(namespace: "ns2")
+
+    expect(ns1[:hits]).to eq(2)
+    expect(ns1[:misses]).to eq(1)
+    expect(ns1[:namespace]).to eq("ns1")
+
+    expect(ns2[:hits]).to eq(1)
+    expect(ns2[:misses]).to eq(0)
+    expect(ns2[:namespace]).to eq("ns2")
+  end
 end

data/spec/modules/metrics_spec.rb

@@ -9,13 +9,16 @@ RSpec.describe Mudis::Metrics do
       
       @metrics = { hits: 5, misses: 3, evictions: 2, rejected: 1 }
       @metrics_mutex = Mutex.new
+      @metrics_by_namespace = {}
+      @metrics_by_namespace_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
+        attr_accessor :metrics, :metrics_mutex, :metrics_by_namespace, :metrics_by_namespace_mutex,
+                      :buckets, :stores, :current_bytes, :lru_nodes
         
         def current_memory_bytes
           @current_bytes.sum

data/spec/modules/persistence_spec.rb

@@ -2,11 +2,10 @@
 
 require_relative "../spec_helper"
 
-RSpec.describe Mudis::Persistence do
-  let(:test_class) do
+RSpec.describe Mudis::Persistence do # rubocop:disable Metrics/BlockLength
+  let(:test_class) do # rubocop:disable Metrics/BlockLength
     Class.new do
       extend Mudis::Persistence
-      
       @persistence_enabled = true
       @persistence_path = "tmp/test_persistence.json"
       @persistence_format = :json
@@ -20,15 +19,14 @@ RSpec.describe Mudis::Persistence do
       @current_bytes = Array.new(2, 0)
       @compress = false
       @serializer = JSON
-      
       class << self
-        attr_accessor :persistence_enabled, :persistence_path, :persistence_format, 
+        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 }
@@ -43,28 +41,28 @@ RSpec.describe Mudis::Persistence do
 
   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.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
@@ -73,9 +71,9 @@ RSpec.describe Mudis::Persistence 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
 
@@ -85,16 +83,16 @@ RSpec.describe Mudis::Persistence do
 
     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
@@ -102,23 +100,23 @@ RSpec.describe Mudis::Persistence do
   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

data/spec/mudis_client_spec.rb

@@ -18,7 +18,7 @@ RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
     if MudisIPCConfig.use_tcp?
       allow(TCPSocket).to receive(:new).and_return(mock_socket)
     else
-      allow(UNIXSocket).to receive(:open).and_yield(mock_socket)
+      allow(UNIXSocket).to receive(:open).and_return(mock_socket)
     end
     allow(mock_socket).to receive(:close)
   end
@@ -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

@@ -6,7 +6,12 @@ require "json"
 require_relative "spec_helper"
 
 RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
-  let(:socket_path) { MudisIPCConfig::SOCKET_PATH }
+  unless ENV["MUDIS_RUN_IPC"] == "true"
+    it "skips IPC socket tests unless MUDIS_RUN_IPC=true" do
+      skip "Set MUDIS_RUN_IPC=true to run IPC socket tests"
+    end
+    next
+  end
 
   before(:all) do
     # Start the server once for all tests
@@ -20,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
 
@@ -36,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
@@ -74,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

data/spec/namespace_spec.rb

@@ -23,6 +23,29 @@ RSpec.describe "Mudis Namespace Operations" do # rubocop:disable Metrics/BlockLe
     expect(Mudis.read("x")).to be_nil
   end
 
+  it "does not double-prefix keys in exists? under thread namespace" do
+    Mudis.with_namespace("ns") do
+      Mudis.write("k", "v")
+      expect(Mudis.exists?("k")).to be true
+    end
+  end
+
+  it "does not double-prefix keys in fetch under thread namespace" do
+    Mudis.with_namespace("ns") do
+      value = Mudis.fetch("k") { "v" }
+      expect(value).to eq("v")
+      expect(Mudis.read("k")).to eq("v")
+    end
+  end
+
+  it "does not double-prefix keys in replace under thread namespace" do
+    Mudis.with_namespace("ns") do
+      Mudis.write("k", "v")
+      Mudis.replace("k", "v2")
+      expect(Mudis.read("k")).to eq("v2")
+    end
+  end
+
   describe ".keys" do
     it "returns only keys for the given namespace" do
       Mudis.write("user:1", "Alice", namespace: "users")