config, request assertion

Author: jablan

clients/cli/spec/cli_spec.rb

@@ -2,18 +2,50 @@
 require "spec_helper"
 
 RSpec.describe "General behavior" do
+  let(:config) { <<~YAML }
+    phrase:
+      host: #{ENV.fetch("BASE_URL")}
+      project_id: "test-project"
+      access_token: "test-token"
+  YAML
+
   it "info prints the version" do
     r = run_cli("info")
     expect(r[:exit_code]).to eq(0)
     expect(r[:stdout]).to include("Phrase Strings client version")
     expect(r[:stderr]).to include("You're running a development version")
   end
 
-  it "handles server 500s cleanly" do
-    # Example: pass a flag so your CLI requests /status/500, if it supports it.
-    # Otherwise adapt your rack app to respond 500 for the request your CLI already makes.
-    r = run_cli("call", "/status/500")
-    expect(r[:exit_code]).not_to eq(0)
-    expect(r[:stderr]).to match(/500|error/i)
+  describe "format commands" do
+    before do
+      mock_set!("GET", "/formats", status: 200, body: [
+        {
+          name: "Ruby/Rails YAML",
+          api_name: "yml",
+          description: "YAML file format for use with Ruby/Rails applications",
+          extension: "yml",
+          default_encoding: "UTF-8",
+          importable: true,
+          exportable: true,
+          default_file: "./config/locales/<locale_name>.yml",
+          renders_default_locale: false,
+          includes_locale_information: true
+        }
+      ])
+    end
+
+    it "gets the format list" do
+      r = run_cli("formats", "list", config:)
+      expect(r[:exit_code]).to eq(0)
+      expect(r[:stdout]).to include("Ruby/Rails YAML")
+
+      requests_made = mock_requests
+      expect(requests_made.length).to eq(1)
+
+      request = requests_made.first
+      expect(request["method"]).to eq("GET")
+      expect(request["path"]).to eq("/formats")
+      expect(request["headers"]["HTTP_AUTHORIZATION"]).to eq("token test-token")
+    end
   end
 end

clients/cli/spec/spec_helper.rb

@@ -2,6 +2,9 @@
 require "open3"
 require "socket"
 require "timeout"
+require "tempfile"
+
+require_relative "support/mock_control"
 
 def free_port
   s = TCPServer.new("127.0.0.1", 0)
@@ -59,19 +62,24 @@ def free_port
       io.close rescue nil
     end
   end
+
+  config.include MockControl
 end
 
 # Point this to your actual binary (relative to repo root, or absolute path)
 CLI_PATH = File.expand_path("../phrase-cli", __dir__)
 # e.g. if it’s built somewhere: File.expand_path("../../target/release/my_cli", __dir__)
 
-def run_cli(*args, env: {})
-  full_env = {
-    # Whatever your CLI reads to find the server:
-    # BASE_URL is set in spec_helper, but you can override per test via env:
-    "BASE_URL" => ENV.fetch("BASE_URL")
-  }.merge(env)
+def run_cli(*args, config: nil, env: {})
+  stdout, stderr, status = if config.nil?
+    Open3.capture3({}, CLI_PATH, *args.map(&:to_s))
+  else
+    Tempfile.create(".phrase.yml") do |f|
+      f.write(config)
+      f.flush
 
-  stdout, stderr, status = Open3.capture3(full_env, CLI_PATH, *args.map(&:to_s))
+      Open3.capture3({}, CLI_PATH, "--config", f.path, *args.map(&:to_s))
+    end
+  end
   { stdout: stdout, stderr: stderr, status: status, exit_code: status.exitstatus }
 end

clients/cli/spec/support/mock_control.rb

@@ -0,0 +1,52 @@
+require "net/http"
+require "json"
+require "uri"
+
+module MockControl
+  def mock_reset!
+    post_json("/__control__/reset", {})
+  end
+
+  def mock_set!(method, path, status:, body:, headers: {})
+    post_json("/__control__/set", {
+      method: method,
+      path: path,
+      status: status,
+      headers: headers,
+      body: body
+    })
+  end
+
+  def mock_requests
+    get_json("/__control__/requests").fetch("requests")
+  end
+
+  def mock_clear_requests!
+    post_json("/__control__/requests/clear", {})
+  end
+
+  private
+
+  def base_uri
+    URI(ENV.fetch("BASE_URL"))
+  end
+
+  def post_json(path, payload)
+    uri = URI.join(base_uri.to_s, path)
+    req = Net::HTTP::Post.new(uri)
+    req["content-type"] = "application/json"
+    req.body = JSON.dump(payload)
+
+    Net::HTTP.start(uri.host, uri.port) do |http|
+      res = http.request(req)
+      raise "Mock control failed: #{res.code} #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+    end
+  end
+
+  def get_json(path)
+    uri = URI.join(base_uri.to_s, path)
+    res = Net::HTTP.get_response(uri)
+    raise "Mock control failed: #{res.code} #{res.body}" unless res.is_a?(Net::HTTPSuccess)
+    JSON.parse(res.body)
+  end
+end

clients/cli/spec/support/mock_server.ru

@@ -1,14 +1,95 @@
 require "json"
 
+$mock = {
+  routes: {},
+  requests: [] # array of hashes
+}
+
+def json(status, obj, headers: {})
+  [status, { "content-type" => "application/json" }.merge(headers), [JSON.dump(obj)]]
+end
+
+def read_body(env)
+  io = env["rack.input"]
+  return "" unless io
+  body = io.read
+  io.rewind if io.respond_to?(:rewind)
+  body
+end
+
+def record_request!(env)
+  method = env["REQUEST_METHOD"]
+  path   = env["PATH_INFO"]
+  query  = env["QUERY_STRING"]
+  body   = read_body(env)
+
+  # Record a safe subset of headers (HTTP_... keys + content-type/length)
+  headers = env.each_with_object({}) do |(k, v), h|
+    next unless k.start_with?("HTTP_") || k == "CONTENT_TYPE" || k == "CONTENT_LENGTH"
+    h[k] = v
+  end
+
+  $mock[:requests] << {
+    method: method,
+    path: path,
+    query: query,
+    headers: headers,
+    body: body
+  }
+end
+
 run lambda { |env|
-  path = env["PATH_INFO"]
+  method = env["REQUEST_METHOD"]
+  path   = env["PATH_INFO"]
+
+  # ---- Control API ----
+  if method == "POST" && path == "/__control__/reset"
+    $mock[:routes].clear
+    $mock[:requests].clear
+    return json(200, { ok: true })
+  end
+
+  if method == "POST" && path == "/__control__/set"
+    payload = JSON.parse(read_body(env))
+    m = payload.fetch("method")
+    p = payload.fetch("path")
 
-  case path
-  when "/ping"
-    [200, { "Content-Type" => "application/json" }, [JSON.dump({ message: "pong" })]]
-  when "/status/500"
-    [500, { "Content-Type" => "application/json" }, [JSON.dump({ error: "boom" })]]
-  else
-    [404, { "Content-Type" => "application/json" }, [JSON.dump({ error: "not found" })]]
+    $mock[:routes][[m, p]] = {
+      status:  payload.fetch("status"),
+      headers: payload["headers"] || {},
+      body:    payload["body"] || ""
+    }
+
+    return json(200, { ok: true })
+  end
+
+  if method == "GET" && path == "/__control__/requests"
+    return json(200, { requests: $mock[:requests] })
   end
+
+  if method == "POST" && path == "/__control__/requests/clear"
+    $mock[:requests].clear
+    return json(200, { ok: true })
+  end
+
+  # ---- Record every non-control request ----
+  record_request!(env)
+
+  # ---- Serve mocked responses ----
+  route = $mock[:routes][[method, path]]
+  return json(404, { error: "not mocked", method: method, path: path }) unless route
+
+  status  = route[:status]
+  headers = route[:headers] || {}
+  body    = route[:body]
+
+  body_str =
+    case body
+    when String then body
+    else JSON.dump(body)
+    end
+
+  headers = { "content-type" => "application/json" }.merge(headers) if body.is_a?(Hash) || body.is_a?(Array)
+
+  [status, headers, [body_str]]
 }