lutaml-store 0.1.1

data/spec/lutaml/store/http_cache_spec.rb

@@ -0,0 +1,422 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/store/http_cache"
+
+RSpec.describe Lutaml::Store::HttpCache do
+  let(:cache_config) do
+    {
+      adapter_type: "memory",
+      default_ttl: 3600,
+      respect_http_headers: true,
+      enable_conditional_requests: true
+    }
+  end
+
+  let(:http_cache) { described_class.new(cache_config) }
+
+  describe "#initialize" do
+    it "accepts hash configuration" do
+      cache = described_class.new(cache_config)
+      expect(cache).to be_a(described_class)
+    end
+
+    it "accepts HttpCacheConfig object" do
+      config = Lutaml::Store::HttpCacheConfig.new(cache_config)
+      cache = described_class.new(config)
+      expect(cache).to be_a(described_class)
+    end
+
+    it "validates configuration" do
+      invalid_config = { adapter_type: "memory", default_ttl: -1 }
+      expect { described_class.new(invalid_config) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe "#fetch" do
+    let(:url) { "http://example.com/api" }
+    let(:method) { "GET" }
+    let(:headers) { { "accept" => "application/json" } }
+    let(:response_data) do
+      {
+        status_code: 200,
+        headers: { "content-type" => "application/json", "cache-control" => "max-age=3600" },
+        body: '{"test": "data"}'
+      }
+    end
+
+    it "requires a block" do
+      expect { http_cache.fetch(method, url, headers) }.to raise_error(ArgumentError)
+    end
+
+    context "cache miss" do
+      it "calls block and caches response" do
+        block_called = false
+        result = http_cache.fetch(method, url, headers) do |request_headers|
+          block_called = true
+          expect(request_headers).to eq(headers)
+          response_data
+        end
+
+        expect(block_called).to be true
+        expect(result).to eq(response_data)
+      end
+
+      it "stores cacheable responses" do
+        http_cache.fetch(method, url, headers) { response_data }
+
+        # Second request should use cache
+        block_called = false
+        result = http_cache.fetch(method, url, headers) do
+          block_called = true
+          raise "Should not be called"
+        end
+
+        expect(block_called).to be false
+        expect(result).to eq(response_data)
+      end
+    end
+
+    context "cache hit" do
+      before do
+        http_cache.fetch(method, url, headers) { response_data }
+      end
+
+      it "returns cached response without calling block" do
+        block_called = false
+        result = http_cache.fetch(method, url, headers) do
+          block_called = true
+          raise "Should not be called"
+        end
+
+        expect(block_called).to be false
+        expect(result).to eq(response_data)
+      end
+    end
+
+    context "conditional requests" do
+      let(:etag_response) do
+        {
+          status_code: 200,
+          headers: { "etag" => '"abc123"', "cache-control" => "max-age=1" },
+          body: "original data"
+        }
+      end
+
+      it "makes conditional request for stale entries" do
+        # Cache initial response
+        http_cache.fetch(method, url, headers) { etag_response }
+
+        # Wait for entry to become stale
+        sleep(1.1)
+
+        # Should make conditional request
+        conditional_request_made = false
+        result = http_cache.fetch(method, url, headers) do |request_headers|
+          conditional_request_made = true
+          expect(request_headers["If-None-Match"]).to eq('"abc123"')
+          { status_code: 304, headers: {}, body: "" }
+        end
+
+        expect(conditional_request_made).to be true
+        expect(result[:body]).to eq("original data") # Returns cached body
+        expect(result[:status_code]).to eq(200) # Returns cached status
+      end
+
+      it "caches new response when content is modified" do
+        # Cache initial response
+        http_cache.fetch(method, url, headers) { etag_response }
+
+        # Wait for entry to become stale
+        sleep(1.1)
+
+        new_response = {
+          status_code: 200,
+          headers: { "etag" => '"def456"' },
+          body: "new data"
+        }
+
+        result = http_cache.fetch(method, url, headers) do |request_headers|
+          expect(request_headers["If-None-Match"]).to eq('"abc123"')
+          new_response
+        end
+
+        expect(result).to eq(new_response)
+      end
+    end
+
+    context "uncacheable responses" do
+      let(:error_response) do
+        {
+          status_code: 404,
+          headers: {},
+          body: "Not Found"
+        }
+      end
+
+      it "does not cache error responses" do
+        result1 = http_cache.fetch(method, url, headers) { error_response }
+        expect(result1).to eq(error_response)
+
+        # Second request should call block again
+        block_called = false
+        result2 = http_cache.fetch(method, url, headers) do
+          block_called = true
+          error_response
+        end
+
+        expect(block_called).to be true
+        expect(result2).to eq(error_response)
+      end
+
+      it "does not cache no-store responses" do
+        no_store_response = {
+          status_code: 200,
+          headers: { "cache-control" => "no-store" },
+          body: "sensitive data"
+        }
+
+        result1 = http_cache.fetch(method, url, headers) { no_store_response }
+        expect(result1).to eq(no_store_response)
+
+        # Second request should call block again
+        block_called = false
+        http_cache.fetch(method, url, headers) do
+          block_called = true
+          no_store_response
+        end
+
+        expect(block_called).to be true
+      end
+    end
+  end
+
+  describe "#get" do
+    let(:url) { "http://example.com/api" }
+    let(:method) { "GET" }
+    let(:headers) { { "accept" => "application/json" } }
+    let(:response_data) do
+      {
+        status_code: 200,
+        headers: { "content-type" => "application/json" },
+        body: '{"test": "data"}'
+      }
+    end
+
+    it "returns nil for cache miss" do
+      result = http_cache.get(method, url, headers)
+      expect(result).to be_nil
+    end
+
+    it "returns cached response for cache hit" do
+      # Cache a response first
+      http_cache.fetch(method, url, headers) { response_data }
+
+      # Get should return cached response
+      result = http_cache.get(method, url, headers)
+      expect(result).to eq(response_data)
+    end
+
+    it "returns nil for stale entries" do
+      stale_response = {
+        status_code: 200,
+        headers: { "cache-control" => "max-age=1" },
+        body: "data"
+      }
+
+      # Cache a response
+      http_cache.fetch(method, url, headers) { stale_response }
+
+      # Wait for it to become stale
+      sleep(1.1)
+
+      # Get should return nil for stale entry
+      result = http_cache.get(method, url, headers)
+      expect(result).to be_nil
+    end
+  end
+
+  describe "#set" do
+    let(:url) { "http://example.com/api" }
+    let(:method) { "GET" }
+    let(:headers) { { "accept" => "application/json" } }
+    let(:response_data) do
+      {
+        status_code: 200,
+        headers: { "content-type" => "application/json" },
+        body: '{"test": "data"}'
+      }
+    end
+
+    it "stores cacheable response" do
+      result = http_cache.set(method, url, headers, response_data)
+      expect(result).to eq(response_data)
+
+      # Verify it was cached
+      cached = http_cache.get(method, url, headers)
+      expect(cached).to eq(response_data)
+    end
+
+    it "does not store uncacheable response" do
+      error_response = {
+        status_code: 404,
+        headers: {},
+        body: "Not Found"
+      }
+
+      result = http_cache.set(method, url, headers, error_response)
+      expect(result).to eq(error_response)
+
+      # Verify it was not cached
+      cached = http_cache.get(method, url, headers)
+      expect(cached).to be_nil
+    end
+  end
+
+  describe "#delete" do
+    let(:url) { "http://example.com/api" }
+    let(:method) { "GET" }
+    let(:headers) { { "accept" => "application/json" } }
+    let(:response_data) do
+      {
+        status_code: 200,
+        headers: { "content-type" => "application/json" },
+        body: '{"test": "data"}'
+      }
+    end
+
+    it "removes cached entry" do
+      # Cache a response
+      http_cache.set(method, url, headers, response_data)
+      expect(http_cache.get(method, url, headers)).to eq(response_data)
+
+      # Delete it
+      http_cache.delete(method, url, headers)
+
+      # Verify it's gone
+      expect(http_cache.get(method, url, headers)).to be_nil
+    end
+
+    it "handles missing entries gracefully" do
+      expect { http_cache.delete(method, url, headers) }.not_to raise_error
+    end
+  end
+
+  describe "#clear" do
+    it "clears all cached entries" do
+      # Cache multiple responses
+      http_cache.set("GET", "http://example.com/api1", {}, {
+                       status_code: 200, headers: {}, body: "data1"
+                     })
+      http_cache.set("GET", "http://example.com/api2", {}, {
+                       status_code: 200, headers: {}, body: "data2"
+                     })
+
+      # Clear cache
+      http_cache.clear
+
+      # Verify entries are gone
+      expect(http_cache.get("GET", "http://example.com/api1", {})).to be_nil
+      expect(http_cache.get("GET", "http://example.com/api2", {})).to be_nil
+    end
+  end
+
+  describe "#stats" do
+    it "returns cache statistics" do
+      stats = http_cache.stats
+
+      expect(stats).to include(
+        adapter_type: "memory",
+        config: hash_including(
+          default_ttl: 3600,
+          max_entries: 10_000,
+          respect_http_headers: true,
+          enable_conditional_requests: true
+        )
+      )
+    end
+  end
+
+  describe "vary header support" do
+    let(:url) { "http://example.com/api" }
+    let(:method) { "GET" }
+
+    it "caches different responses for different vary headers" do
+      pending "WIP: vary header caching not yet implemented"
+      vary_response = {
+        status_code: 200,
+        headers: { "vary" => "Accept-Encoding", "content-type" => "application/json" },
+        body: '{"compressed": false}'
+      }
+
+      gzip_response = {
+        status_code: 200,
+        headers: { "vary" => "Accept-Encoding", "content-type" => "application/json" },
+        body: '{"compressed": true}'
+      }
+
+      # Cache response for no encoding
+      result1 = http_cache.fetch(method, url, {}) { vary_response }
+      expect(result1).to eq(vary_response)
+
+      # Cache response for gzip encoding
+      result2 = http_cache.fetch(method, url, { "accept-encoding" => "gzip" }) { gzip_response }
+      expect(result2).to eq(gzip_response)
+
+      # Verify both are cached separately
+      cached1 = http_cache.get(method, url, {})
+      cached2 = http_cache.get(method, url, { "accept-encoding" => "gzip" })
+
+      expect(cached1[:body]).to eq('{"compressed": false}')
+      expect(cached2[:body]).to eq('{"compressed": true}')
+    end
+  end
+
+  describe "query parameter handling" do
+    let(:method) { "GET" }
+    let(:headers) { {} }
+    let(:response_data) do
+      {
+        status_code: 200,
+        headers: {},
+        body: "data"
+      }
+    end
+
+    it "normalizes query parameter order" do
+      url1 = "http://example.com/api?b=2&a=1"
+      url2 = "http://example.com/api?a=1&b=2"
+
+      # Cache response for first URL
+      http_cache.set(method, url1, headers, response_data)
+
+      # Second URL should hit cache (same normalized key)
+      cached = http_cache.get(method, url2, headers)
+      expect(cached).to eq(response_data)
+    end
+
+    context "with ignored parameters" do
+      let(:cache_config_with_ignored_params) do
+        {
+          adapter_type: "memory",
+          default_ttl: 3600,
+          ignore_query_params: %w[timestamp nonce]
+        }
+      end
+
+      let(:http_cache) { described_class.new(cache_config_with_ignored_params) }
+
+      it "ignores specified query parameters" do
+        url1 = "http://example.com/api?data=value&timestamp=123"
+        url2 = "http://example.com/api?data=value&timestamp=456"
+
+        # Cache response for first URL
+        http_cache.set(method, url1, headers, response_data)
+
+        # Second URL should hit cache (timestamp ignored)
+        cached = http_cache.get(method, url2, headers)
+        expect(cached).to eq(response_data)
+      end
+    end
+  end
+end

data/spec/lutaml/store/http_header_processor_spec.rb

@@ -0,0 +1,290 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/store/http_header_processor"
+
+RSpec.describe Lutaml::Store::HttpHeaderProcessor do
+  describe ".parse_cache_control" do
+    it "parses simple directives" do
+      result = described_class.parse_cache_control("no-cache, no-store")
+      expect(result).to eq({
+                             "no-cache" => true,
+                             "no-store" => true
+                           })
+    end
+
+    it "parses directives with values" do
+      result = described_class.parse_cache_control("max-age=3600, s-maxage=7200")
+      expect(result).to eq({
+                             "max-age" => 3600,
+                             "s-maxage" => 7200
+                           })
+    end
+
+    it "parses quoted values" do
+      result = described_class.parse_cache_control('max-age="3600", custom="value"')
+      expect(result).to eq({
+                             "max-age" => 3600,
+                             "custom" => "value"
+                           })
+    end
+
+    it "handles nil input" do
+      result = described_class.parse_cache_control(nil)
+      expect(result).to eq({})
+    end
+
+    it "handles empty string" do
+      result = described_class.parse_cache_control("")
+      expect(result).to eq({})
+    end
+  end
+
+  describe ".calculate_expiry" do
+    let(:cached_at) { Time.now }
+    let(:default_ttl) { 3600 }
+
+    context "with Expires header" do
+      it "uses Expires header when present" do
+        expires_time = Time.now + 7200
+        headers = { "expires" => expires_time.httpdate }
+
+        result = described_class.calculate_expiry(headers, cached_at, default_ttl)
+        expect(result).to be_within(1).of(expires_time)
+      end
+
+      it "handles invalid Expires header gracefully" do
+        headers = { "expires" => "invalid-date" }
+
+        result = described_class.calculate_expiry(headers, cached_at, default_ttl)
+        expect(result).to be_within(1).of(cached_at + default_ttl)
+      end
+    end
+
+    context "with Cache-Control max-age" do
+      it "uses max-age when present" do
+        headers = { "cache-control" => "max-age=7200" }
+
+        result = described_class.calculate_expiry(headers, cached_at, default_ttl)
+        expect(result).to be_within(1).of(cached_at + 7200)
+      end
+    end
+
+    context "with no caching headers" do
+      it "falls back to default TTL" do
+        headers = {}
+
+        result = described_class.calculate_expiry(headers, cached_at, default_ttl)
+        expect(result).to be_within(1).of(cached_at + default_ttl)
+      end
+    end
+  end
+
+  describe ".should_cache_response?" do
+    it "caches successful responses" do
+      result = described_class.should_cache_response?(200, {})
+      expect(result).to be true
+    end
+
+    it "does not cache error responses" do
+      result = described_class.should_cache_response?(404, {})
+      expect(result).to be false
+    end
+
+    it "does not cache responses with no-store" do
+      headers = { "cache-control" => "no-store" }
+      result = described_class.should_cache_response?(200, headers)
+      expect(result).to be false
+    end
+
+    it "does not cache private responses" do
+      headers = { "cache-control" => "private" }
+      result = described_class.should_cache_response?(200, headers)
+      expect(result).to be false
+    end
+  end
+
+  describe ".generate_cache_key" do
+    it "generates basic cache key" do
+      result = described_class.generate_cache_key("GET", "http://example.com/api")
+      expect(result).to eq("GET:http://example.com/api")
+    end
+
+    it "normalizes query parameters" do
+      result = described_class.generate_cache_key("GET", "http://example.com/api?b=2&a=1")
+      expect(result).to eq("GET:http://example.com/api?a=1&b=2")
+    end
+
+    it "filters ignored parameters" do
+      result = described_class.generate_cache_key(
+        "GET",
+        "http://example.com/api?timestamp=123&data=value",
+        {},
+        ["timestamp"]
+      )
+      expect(result).to eq("GET:http://example.com/api?data=value")
+    end
+
+    it "includes vary headers in key" do
+      vary_headers = { "accept-encoding" => "gzip", "accept-language" => "en" }
+      result = described_class.generate_cache_key("GET", "http://example.com/api", vary_headers)
+
+      expect(result).to start_with("GET:http://example.com/api|")
+      expect(result).to include(Digest::SHA256.hexdigest("accept-encoding:gzip|accept-language:en")[0..8])
+    end
+  end
+
+  describe ".parse_vary_header" do
+    it "parses single header" do
+      result = described_class.parse_vary_header("Accept-Encoding")
+      expect(result).to eq(["accept-encoding"])
+    end
+
+    it "parses multiple headers" do
+      result = described_class.parse_vary_header("Accept-Encoding, Accept-Language, User-Agent")
+      expect(result).to eq(%w[accept-encoding accept-language user-agent])
+    end
+
+    it "handles nil input" do
+      result = described_class.parse_vary_header(nil)
+      expect(result).to eq([])
+    end
+  end
+
+  describe ".extract_vary_headers" do
+    let(:request_headers) do
+      {
+        "Accept-Encoding" => "gzip, deflate",
+        "Accept-Language" => "en-US,en;q=0.9",
+        "User-Agent" => "Mozilla/5.0"
+      }
+    end
+
+    it "extracts specified headers" do
+      vary_names = %w[accept-encoding accept-language]
+      result = described_class.extract_vary_headers(request_headers, vary_names)
+
+      expect(result).to eq({
+                             "accept-encoding" => "gzip, deflate",
+                             "accept-language" => "en-US,en;q=0.9"
+                           })
+    end
+
+    it "handles case-insensitive matching" do
+      vary_names = ["ACCEPT-ENCODING"]
+      result = described_class.extract_vary_headers(request_headers, vary_names)
+
+      expect(result).to eq({
+                             "accept-encoding" => "gzip, deflate"
+                           })
+    end
+
+    it "returns empty hash for empty vary names" do
+      result = described_class.extract_vary_headers(request_headers, [])
+      expect(result).to eq({})
+    end
+  end
+
+  describe ".fresh?" do
+    let(:cached_at) { Time.now - 1800 } # 30 minutes ago
+
+    it "returns true when not expired" do
+      expires_at = Time.now + 1800 # 30 minutes from now
+      result = described_class.fresh?(cached_at, 3600, expires_at)
+      expect(result).to be true
+    end
+
+    it "returns false when expires_at is past" do
+      expires_at = Time.now - 100
+      result = described_class.fresh?(cached_at, 3600, expires_at)
+      expect(result).to be false
+    end
+
+    it "returns false when max_age is exceeded" do
+      result = described_class.fresh?(cached_at, 1000, nil) # max_age less than age
+      expect(result).to be false
+    end
+  end
+
+  describe ".build_conditional_headers" do
+    let(:cache_entry) do
+      double(
+        etag: '"abc123"',
+        last_modified: Time.parse("2023-01-01 12:00:00 UTC")
+      )
+    end
+
+    it "adds If-None-Match for ETag" do
+      original_headers = { "accept" => "application/json" }
+      result = described_class.build_conditional_headers(cache_entry, original_headers)
+
+      expect(result["If-None-Match"]).to eq('"abc123"')
+      expect(result["accept"]).to eq("application/json")
+    end
+
+    it "adds If-Modified-Since for Last-Modified" do
+      original_headers = { "accept" => "application/json" }
+      result = described_class.build_conditional_headers(cache_entry, original_headers)
+
+      expect(result["If-Modified-Since"]).to eq("Sun, 01 Jan 2023 12:00:00 GMT")
+    end
+
+    it "handles missing ETag and Last-Modified" do
+      cache_entry_without_headers = double(etag: nil, last_modified: nil)
+      original_headers = { "accept" => "application/json" }
+
+      result = described_class.build_conditional_headers(cache_entry_without_headers, original_headers)
+
+      expect(result["If-None-Match"]).to be_nil
+      expect(result["If-Modified-Since"]).to be_nil
+      expect(result["accept"]).to eq("application/json")
+    end
+  end
+
+  describe ".parse_last_modified" do
+    it "parses valid date" do
+      date_string = "Sun, 01 Jan 2023 12:00:00 GMT"
+      result = described_class.parse_last_modified(date_string)
+
+      expect(result).to be_a(Time)
+      expect(result.year).to eq(2023)
+    end
+
+    it "handles invalid date gracefully" do
+      result = described_class.parse_last_modified("invalid-date")
+      expect(result).to be_nil
+    end
+
+    it "handles nil input" do
+      result = described_class.parse_last_modified(nil)
+      expect(result).to be_nil
+    end
+  end
+
+  describe ".has_caching_directives?" do
+    it "returns true for Cache-Control header" do
+      headers = { "cache-control" => "max-age=3600" }
+      expect(described_class.has_caching_directives?(headers)).to be true
+    end
+
+    it "returns true for Expires header" do
+      headers = { "expires" => "Sun, 01 Jan 2024 12:00:00 GMT" }
+      expect(described_class.has_caching_directives?(headers)).to be true
+    end
+
+    it "returns true for ETag header" do
+      headers = { "etag" => '"abc123"' }
+      expect(described_class.has_caching_directives?(headers)).to be true
+    end
+
+    it "returns true for Last-Modified header" do
+      headers = { "last-modified" => "Sun, 01 Jan 2023 12:00:00 GMT" }
+      expect(described_class.has_caching_directives?(headers)).to be true
+    end
+
+    it "returns false for no caching headers" do
+      headers = { "content-type" => "application/json" }
+      expect(described_class.has_caching_directives?(headers)).to be false
+    end
+  end
+end