mudis 0.8.0 → 0.9.0

data/spec/mudis_client_spec.rb

@@ -1,137 +1,147 @@
-# 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
+# frozen_string_literal: true
+
+require_relative "spec_helper"
+
+RSpec.describe MudisClient do # rubocop:disable Metrics/BlockLength
+  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|
+    ClimateControl.modify("SOCKET_PATH" => socket_path) do
+      example.run
+    end
+  end
+
+  before do
+    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
+    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
+      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(/Cannot connect/).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

@@ -1,90 +1,100 @@
-# 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
+# frozen_string_literal: true
+
+require "socket"
+require "json"
+
+require_relative "spec_helper"
+
+RSpec.describe MudisServer do # rubocop:disable Metrics/BlockLength
+  let(:socket_path) { MudisIPCConfig::SOCKET_PATH }
+
+  before(:all) do
+    # Start the server once for all tests
+    Thread.new { MudisServer.start! }
+    sleep 0.2 # Allow the server to start
+  end
+
+  before(:each) 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!)
+  end
+
+  after do
+    File.unlink(socket_path) if File.exist?(socket_path) && !MudisIPCConfig.use_tcp?
+  end
+
+  def send_request(request)
+    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
+
+  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, 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, value: nil })
+    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, 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, value: nil })
+    expect(Mudis).to have_received(:reset!)
+  end
+
+  it "handles unknown commands" do
+    response = send_request({ cmd: "unknown_command" })
+    expect(response[:ok]).to be false
+    expect(response[:error]).to match(/unknown command/i)
+  end
+end