lutaml-store 0.1.1

data/spec/lutaml/store/corrected_http_cache_integration_spec.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/store/http_cache"
+
+# Mock W3C API components for testing
+module MockW3cApi
+  class MockClient
+    def get(url)
+      { "data" => "test response", "url" => url }
+    end
+
+    def get_with_headers(url, headers)
+      response = { "data" => "test response with headers", "url" => url }
+      # Simulate ETag header
+      response["etag"] = '"test-etag-123"' if headers["If-None-Match"]
+      response
+    end
+
+    def get_by_url(url)
+      { "data" => "test response by url", "url" => url }
+    end
+
+    def api_url
+      "https://api.w3.org"
+    end
+  end
+
+  class MockModel
+    def self.from_json(json)
+      data = JSON.parse(json)
+      new(data)
+    end
+
+    def initialize(data)
+      @data = data
+    end
+
+    attr_reader :data
+
+    def to_json(*_args)
+      @data.to_json
+    end
+  end
+
+  class MockParameter
+    attr_reader :name, :location, :required, :default_value
+
+    def initialize(name, location: :query, required: false, default_value: nil)
+      @name = name.to_s
+      @location = location
+      @required = required
+      @default_value = default_value
+    end
+
+    def validate!
+      raise ArgumentError, "Parameter name cannot be empty" if @name.nil? || @name.empty?
+    end
+
+    def path_parameter?
+      @location == :path
+    end
+
+    def query_parameter?
+      @location == :query
+    end
+
+    def validate_value(value)
+      !value.nil?
+    end
+  end
+end
+
+RSpec.describe "Corrected HTTP Cache Integration", skip: "WIP: HTTP cache integration not yet implemented" do
+  let(:cache_config) do
+    {
+      adapter_type: :memory,
+      default_ttl: 3600,
+      respect_http_headers: true,
+      enable_conditional_requests: true
+    }
+  end
+
+  let(:cache) { Lutaml::Store::HttpCache.new(cache_config) }
+  let(:client) { MockW3cApi::MockClient.new }
+  let(:register) { Lutaml::Hal::ModelRegister.new(name: :test, client: client, cache: cache_config) }
+
+  before do
+    # Configure the register with HTTP cache
+    register.cache_store = cache
+  end
+
+  describe "transparent cache integration" do
+    it "integrates cache at ModelRegister.fetch() level" do
+      # Add a test endpoint
+      register.add_endpoint(
+        id: :test_endpoint,
+        type: :index,
+        url: "/test",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # First request should hit the API
+      expect(client).to receive(:get).with("https://api.w3.org/test").and_call_original
+      result1 = register.fetch(:test_endpoint)
+
+      # Second request should hit the cache
+      expect(client).not_to receive(:get)
+      result2 = register.fetch(:test_endpoint)
+
+      # Results should be equivalent
+      expect(result1.data["url"]).to eq(result2.data["url"])
+    end
+
+    it "supports HTTP-aware caching with conditional requests" do
+      # Add a test endpoint
+      register.add_endpoint(
+        id: :test_conditional,
+        type: :index,
+        url: "/test-conditional",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # First request
+      result1 = register.fetch(:test_conditional)
+      expect(result1).to be_a(MockW3cApi::MockModel)
+
+      # Second request should use conditional headers
+      result2 = register.fetch(:test_conditional)
+      expect(result2).to be_a(MockW3cApi::MockModel)
+    end
+
+    it "handles query parameters correctly" do
+      # Add endpoint with query parameters
+      register.add_endpoint(
+        id: :test_with_params,
+        type: :index,
+        url: "/test-params",
+        model: MockW3cApi::MockModel,
+        parameters: [
+          MockW3cApi::MockParameter.new("page", location: :query),
+          MockW3cApi::MockParameter.new("items", location: :query)
+        ]
+      )
+
+      # Test with different parameters
+      result1 = register.fetch(:test_with_params, page: 1, items: 10)
+      result2 = register.fetch(:test_with_params, page: 2, items: 10)
+      result3 = register.fetch(:test_with_params, page: 1, items: 10) # Should hit cache
+
+      expect(result1.data["url"]).to include("page=1")
+      expect(result2.data["url"]).to include("page=2")
+      expect(result3.data["url"]).to eq(result1.data["url"])
+    end
+
+    it "handles path parameters correctly" do
+      # Add endpoint with path parameters
+      register.add_endpoint(
+        id: :test_with_path,
+        type: :resource,
+        url: "/test/{id}",
+        model: MockW3cApi::MockModel,
+        parameters: [
+          MockW3cApi::MockParameter.new("id", location: :path)
+        ]
+      )
+
+      result = register.fetch(:test_with_path, id: "test-123")
+      expect(result.data["url"]).to include("/test/test-123")
+    end
+  end
+
+  describe "cache configuration methods" do
+    let(:mock_hal) do
+      hal = double("Hal")
+      mock_register = double("Register")
+      allow(hal).to receive(:register).and_return(mock_register)
+      allow(mock_register).to receive(:cache_store=)
+      allow(mock_register).to receive(:cache_info).and_return({
+                                                                adapter_type: "Memory",
+                                                                current_size: 5,
+                                                                default_ttl: 3600
+                                                              })
+      allow(mock_register).to receive(:clear_cache)
+      allow(mock_register).to receive(:cache_stats).and_return({
+                                                                 hits: 10,
+                                                                 misses: 5,
+                                                                 hit_rate: 0.67
+                                                               })
+      hal
+    end
+
+    it "provides configure_cache method" do
+      expect(mock_hal.register).to receive(:cache_store=).with(cache)
+
+      # Simulate the configure_cache method
+      mock_hal.register.cache_store = cache
+    end
+
+    it "provides cache_info method" do
+      info = mock_hal.register.cache_info
+      expect(info).to include(:adapter_type, :current_size, :default_ttl)
+    end
+
+    it "provides clear_cache method" do
+      expect(mock_hal.register).to receive(:clear_cache)
+      mock_hal.register.clear_cache
+    end
+
+    it "provides cache_stats method" do
+      stats = mock_hal.register.cache_stats
+      expect(stats).to include(:hits, :misses, :hit_rate)
+    end
+  end
+
+  describe "HTTP semantics preservation" do
+    it "respects HTTP headers" do
+      expect(cache.config.respect_http_headers).to be true
+    end
+
+    it "enables conditional requests" do
+      expect(cache.config.enable_conditional_requests).to be true
+    end
+
+    it "handles ETags correctly" do
+      # This would be tested with actual HTTP responses
+      # For now, we verify the cache is configured to handle them
+      expect(cache.config.respect_http_headers).to be true
+    end
+  end
+
+  describe "zero API changes requirement" do
+    it "maintains existing ModelRegister interface" do
+      # Verify that cache integration doesn't break existing interface
+      expect(register).to respond_to(:fetch)
+      expect(register).to respond_to(:add_endpoint)
+      expect(register).to respond_to(:models)
+      expect(register).to respond_to(:client)
+    end
+
+    it "supports optional cache configuration" do
+      # Register should work without cache
+      no_cache_register = Lutaml::Hal::ModelRegister.new(name: :no_cache, client: client)
+      expect(no_cache_register.cache_store).to be_nil
+
+      # And with cache
+      cached_register = Lutaml::Hal::ModelRegister.new(name: :cached, client: client, cache: cache_config)
+      expect(cached_register.cache_store).not_to be_nil
+    end
+  end
+
+  describe "architectural correctness" do
+    it "integrates at the correct layer (ModelRegister.fetch)" do
+      # Verify that cache is checked in fetch method
+      register.add_endpoint(
+        id: :arch_test,
+        type: :index,
+        url: "/arch-test",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # Mock the cache to verify it's being used
+      expect(cache).to receive(:fetch).and_call_original
+      register.fetch(:arch_test)
+    end
+
+    it "does not bypass w3c_api gem architecture" do
+      # This test ensures we're not creating direct HTTP clients
+      # Instead, we use the existing client through ModelRegister
+      expect(register.client).to be_a(MockW3cApi::MockClient)
+      expect(register.client).to respond_to(:get)
+      expect(register.client).to respond_to(:get_with_headers)
+    end
+  end
+
+  describe "performance benefits" do
+    it "provides measurable cache improvements" do
+      register.add_endpoint(
+        id: :perf_test,
+        type: :index,
+        url: "/perf-test",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # First request (cache miss)
+      start_time = Time.now
+      register.fetch(:perf_test)
+      first_duration = Time.now - start_time
+
+      # Second request (cache hit)
+      start_time = Time.now
+      register.fetch(:perf_test)
+      second_duration = Time.now - start_time
+
+      # Cache hit should be faster (though in memory it might be negligible)
+      expect(second_duration).to be <= first_duration
+    end
+  end
+
+  describe "error handling" do
+    it "handles cache failures gracefully" do
+      # Mock cache failure
+      allow(cache).to receive(:fetch).and_raise(StandardError, "Cache error")
+
+      register.add_endpoint(
+        id: :error_test,
+        type: :index,
+        url: "/error-test",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # Should fall back to direct API call
+      expect { register.fetch(:error_test) }.not_to raise_error
+    end
+
+    it "handles missing cache gracefully" do
+      no_cache_register = Lutaml::Hal::ModelRegister.new(name: :no_cache, client: client)
+
+      no_cache_register.add_endpoint(
+        id: :no_cache_test,
+        type: :index,
+        url: "/no-cache-test",
+        model: MockW3cApi::MockModel,
+        parameters: []
+      )
+
+      # Should work without cache
+      expect { no_cache_register.fetch(:no_cache_test) }.not_to raise_error
+    end
+  end
+end

data/spec/lutaml/store/custom_serializer_spec.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store, "custom serializer" do
+  let(:custom_serializer) do
+    Class.new do
+      def serialize(model)
+        { "identifier" => model.identifier, "value" => model.value }
+      end
+
+      def deserialize(data, _model_class)
+        model = TestCustomModel.new
+        model.identifier = data["identifier"]
+        model.value = data["value"]
+        model
+      end
+    end.new
+  end
+
+  before do
+    stub_const("TestCustomModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :identifier, :string
+      attribute :value, :string
+      attribute :computed, :string
+
+      def computed
+        "#{identifier}-#{value}"
+      end
+    end)
+  end
+
+  it "uses custom serializer for save and fetch" do
+    store = described_class.new(
+      adapter: :memory,
+      models: [
+        { model: TestCustomModel, key: :identifier, serializer: custom_serializer }
+      ]
+    )
+
+    model = TestCustomModel.new
+    model.identifier = "abc"
+    model.value = "hello"
+
+    store.save(model)
+
+    fetched = store.fetch(model: TestCustomModel, identifier: "abc")
+    expect(fetched.identifier).to eq("abc")
+    expect(fetched.value).to eq("hello")
+    expect(fetched.computed).to eq("abc-hello")
+  end
+
+  it "uses custom serializer for all" do
+    store = described_class.new(
+      adapter: :memory,
+      models: [
+        { model: TestCustomModel, key: :identifier, serializer: custom_serializer }
+      ]
+    )
+
+    3.times do |i|
+      model = TestCustomModel.new
+      model.identifier = "item-#{i}"
+      model.value = "val-#{i}"
+      store.save(model)
+    end
+
+    all_items = store.all(model: TestCustomModel)
+    expect(all_items.size).to eq(3)
+    expect(all_items.map(&:value).sort).to eq(%w[val-0 val-1 val-2])
+  end
+
+  it "uses custom serializer for update" do
+    store = described_class.new(
+      adapter: :memory,
+      models: [
+        { model: TestCustomModel, key: :identifier, serializer: custom_serializer }
+      ]
+    )
+
+    model = TestCustomModel.new
+    model.identifier = "xyz"
+    model.value = "original"
+    store.save(model)
+
+    updated = store.update(
+      model: TestCustomModel,
+      identifier: "xyz",
+      attributes: { "value" => "updated" }
+    )
+    expect(updated.value).to eq("updated")
+  end
+
+  it "falls back to default serialization when no custom serializer" do
+    store = described_class.new(
+      adapter: :memory,
+      models: [{ model: TestCustomModel, key: :identifier }]
+    )
+
+    model = TestCustomModel.new
+    model.identifier = "default"
+    model.value = "normal"
+    store.save(model)
+
+    fetched = store.fetch(model: TestCustomModel, identifier: "default")
+    expect(fetched.identifier).to eq("default")
+  end
+end