lutaml-store 0.1.1

data/spec/lutaml/store/lutaml_model_integration_spec.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+module IntegrationTestModels
+  class TestDocument < Lutaml::Model::Serializable
+    attribute :id, :string
+    attribute :title, :string
+    attribute :content, :string
+    attribute :created_at, :string
+
+    key_value do
+      map :id, to: :id
+      map :title, to: :title
+      map :content, to: :content
+      map :created_at, to: :created_at
+    end
+  end
+
+  class TestAuthor < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :email, :string
+    attribute :bio, :string
+
+    key_value do
+      map :name, to: :name
+      map :email, to: :email
+      map :bio, to: :bio
+    end
+  end
+
+  class TestBook < Lutaml::Model::Serializable
+    attribute :isbn, :string
+    attribute :title, :string
+    attribute :author, :string
+    attribute :published_year, :integer
+    attribute :genre, :string
+
+    key_value do
+      map :isbn, to: :isbn
+      map :title, to: :title
+      map :author, to: :author
+      map :published_year, to: :published_year
+      map :genre, to: :genre
+    end
+  end
+end
+
+RSpec.describe "Lutaml::Store with Lutaml::Model::Serializable integration" do
+  let(:doc_model) { { model: IntegrationTestModels::TestDocument, key: :id, dir: "documents" } }
+  let(:author_model) { { model: IntegrationTestModels::TestAuthor, key: :name, dir: "authors" } }
+  let(:book_model) { { model: IntegrationTestModels::TestBook, key: :isbn, dir: "books" } }
+
+  describe "single model CRUD" do
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [doc_model]) }
+    let(:document) do
+      IntegrationTestModels::TestDocument.new(
+        id: "doc1", title: "Test Document",
+        content: "This is a test", created_at: "2024-01-01"
+      )
+    end
+
+    it "saves and fetches a Lutaml::Model::Serializable instance" do
+      store.save(document)
+
+      retrieved = store.fetch(model: IntegrationTestModels::TestDocument, id: "doc1")
+      expect(retrieved).to be_a(IntegrationTestModels::TestDocument)
+      expect(retrieved.id).to eq("doc1")
+      expect(retrieved.title).to eq("Test Document")
+      expect(retrieved.content).to eq("This is a test")
+      expect(retrieved.created_at).to eq("2024-01-01")
+    end
+
+    it "returns nil for non-existent key" do
+      expect(store.fetch(model: IntegrationTestModels::TestDocument, id: "missing")).to be_nil
+    end
+
+    it "updates a model with hash attributes" do
+      store.save(document)
+
+      updated = store.update(
+        model: IntegrationTestModels::TestDocument,
+        id: "doc1",
+        attributes: { title: "Updated Title" }
+      )
+      expect(updated.title).to eq("Updated Title")
+      expect(updated.content).to eq("This is a test")
+    end
+
+    it "updates a model with block" do
+      store.save(document)
+
+      updated = store.update(model: IntegrationTestModels::TestDocument, id: "doc1") do |model|
+        model.content = "New content"
+        model
+      end
+      expect(updated.content).to eq("New content")
+    end
+
+    it "deletes a model" do
+      store.save(document)
+      expect(store.exists?(model: IntegrationTestModels::TestDocument, id: "doc1")).to be true
+
+      result = store.destroy(model: IntegrationTestModels::TestDocument, id: "doc1")
+      expect(result).to be true
+      expect(store.fetch(model: IntegrationTestModels::TestDocument, id: "doc1")).to be_nil
+    end
+
+    it "reports count and exists" do
+      expect(store.count(model: IntegrationTestModels::TestDocument)).to eq(0)
+
+      store.save(document)
+      expect(store.count(model: IntegrationTestModels::TestDocument)).to eq(1)
+      expect(store.exists?(model: IntegrationTestModels::TestDocument, id: "doc1")).to be true
+    end
+  end
+
+  describe "model type validation" do
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [doc_model]) }
+
+    it "raises when saving an unregistered model" do
+      author = IntegrationTestModels::TestAuthor.new(name: "John Doe", email: "john@example.com")
+
+      expect { store.save(author) }.to raise_error(Lutaml::Store::ModelNotRegisteredError)
+    end
+  end
+
+  describe "collection operations" do
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [author_model]) }
+    let(:authors) do
+      [
+        IntegrationTestModels::TestAuthor.new(name: "Alice Johnson", email: "alice@example.com", bio: "Fiction writer"),
+        IntegrationTestModels::TestAuthor.new(name: "Bob Wilson", email: "bob@example.com", bio: "Technical writer"),
+        IntegrationTestModels::TestAuthor.new(name: "Carol Davis", email: "carol@example.com", bio: "Science writer")
+      ]
+    end
+
+    it "stores multiple models and retrieves all" do
+      authors.each { |a| store.save(a) }
+
+      all_authors = store.all(model: IntegrationTestModels::TestAuthor)
+      expect(all_authors.size).to eq(3)
+      expect(all_authors.map(&:name).sort).to eq(["Alice Johnson", "Bob Wilson", "Carol Davis"])
+    end
+
+    it "queries with where" do
+      authors.each { |a| store.save(a) }
+
+      fiction = store.where(model: IntegrationTestModels::TestAuthor, bio: "Fiction writer")
+      expect(fiction.size).to eq(1)
+      expect(fiction.first.name).to eq("Alice Johnson")
+    end
+
+    it "updates a model and persists the change" do
+      authors.each { |a| store.save(a) }
+
+      store.update(model: IntegrationTestModels::TestAuthor, name: "Alice Johnson") do |model|
+        model.bio = "Updated bio: Fiction and mystery writer"
+        model
+      end
+
+      retrieved = store.fetch(model: IntegrationTestModels::TestAuthor, name: "Alice Johnson")
+      expect(retrieved.bio).to eq("Updated bio: Fiction and mystery writer")
+    end
+  end
+
+  describe "multi-model store" do
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [doc_model, author_model, book_model]) }
+
+    it "stores and retrieves different model types independently" do
+      document = IntegrationTestModels::TestDocument.new(id: "doc1", title: "Test Doc")
+      author = IntegrationTestModels::TestAuthor.new(name: "John Doe", email: "john@example.com")
+      book = IntegrationTestModels::TestBook.new(isbn: "978-123", title: "Test Book", author: "John Doe",
+                                                 published_year: 2024, genre: "Fiction")
+
+      store.save(document)
+      store.save(author)
+      store.save(book)
+
+      expect(store.count(model: IntegrationTestModels::TestDocument)).to eq(1)
+      expect(store.count(model: IntegrationTestModels::TestAuthor)).to eq(1)
+      expect(store.count(model: IntegrationTestModels::TestBook)).to eq(1)
+
+      fetched_doc = store.fetch(model: IntegrationTestModels::TestDocument, id: "doc1")
+      fetched_author = store.fetch(model: IntegrationTestModels::TestAuthor, name: "John Doe")
+      fetched_book = store.fetch(model: IntegrationTestModels::TestBook, isbn: "978-123")
+
+      expect(fetched_doc).to be_a(IntegrationTestModels::TestDocument)
+      expect(fetched_author).to be_a(IntegrationTestModels::TestAuthor)
+      expect(fetched_book).to be_a(IntegrationTestModels::TestBook)
+    end
+
+    it "isolates where queries by model type" do
+      store.save(IntegrationTestModels::TestDocument.new(id: "d1", title: "Ruby Guide"))
+      store.save(IntegrationTestModels::TestBook.new(isbn: "b1", title: "Ruby Guide", author: "Author"))
+
+      docs = store.where(model: IntegrationTestModels::TestDocument, title: "Ruby Guide")
+      books = store.where(model: IntegrationTestModels::TestBook, title: "Ruby Guide")
+
+      expect(docs.size).to eq(1)
+      expect(docs.first).to be_a(IntegrationTestModels::TestDocument)
+      expect(books.size).to eq(1)
+      expect(books.first).to be_a(IntegrationTestModels::TestBook)
+    end
+  end
+
+  describe "file I/O round-trip" do
+    let(:tmpdir) { Dir.mktmpdir }
+    after { FileUtils.rm_rf(tmpdir) }
+
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [book_model]) }
+    let(:books) do
+      [
+        IntegrationTestModels::TestBook.new(isbn: "978-0123456789", title: "Ruby Programming", author: "Jane Smith",
+                                            published_year: 2023, genre: "Programming"),
+        IntegrationTestModels::TestBook.new(isbn: "978-9876543210", title: "Go Programming", author: "Bob Jones",
+                                            published_year: 2024, genre: "Programming")
+      ]
+    end
+
+    it "round-trips through YAML separate layout" do
+      store.save_all(books, path: tmpdir, format: :yaml, layout: :separate)
+
+      fresh_store = Lutaml::Store.new(adapter: :memory, models: [book_model])
+      loaded = fresh_store.load_all(IntegrationTestModels::TestBook, path: tmpdir, format: :yaml, layout: :separate)
+
+      expect(loaded.size).to eq(2)
+      expect(loaded.map(&:title).sort).to eq(["Go Programming", "Ruby Programming"])
+    end
+
+    it "round-trips through JSON separate layout" do
+      store.save_all(books, path: tmpdir, format: :json, layout: :separate)
+
+      fresh_store = Lutaml::Store.new(adapter: :memory, models: [book_model])
+      loaded = fresh_store.load_all(IntegrationTestModels::TestBook, path: tmpdir, format: :json, layout: :separate)
+
+      expect(loaded.size).to eq(2)
+      expect(loaded.map(&:author).sort).to eq(["Bob Jones", "Jane Smith"])
+    end
+  end
+
+  describe "import_all workflow" do
+    let(:tmpdir) { Dir.mktmpdir }
+    after { FileUtils.rm_rf(tmpdir) }
+
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [doc_model]) }
+    let(:documents) do
+      [
+        IntegrationTestModels::TestDocument.new(id: "doc1", title: "First Document", content: "Content 1"),
+        IntegrationTestModels::TestDocument.new(id: "doc2", title: "Second Document", content: "Content 2")
+      ]
+    end
+
+    it "loads from directory and makes models queryable" do
+      store.save_all(documents, path: tmpdir, format: :yaml, layout: :separate)
+
+      fresh_store = Lutaml::Store.new(adapter: :memory, models: [doc_model])
+      loaded = fresh_store.import_all(IntegrationTestModels::TestDocument, path: tmpdir, format: :yaml,
+                                                                           layout: :separate)
+
+      expect(loaded.size).to eq(2)
+
+      # Queryable via fetch
+      doc1 = fresh_store.fetch(model: IntegrationTestModels::TestDocument, id: "doc1")
+      expect(doc1).not_to be_nil
+      expect(doc1.title).to eq("First Document")
+
+      # Queryable via where
+      second = fresh_store.where(model: IntegrationTestModels::TestDocument, title: "Second Document")
+      expect(second.size).to eq(1)
+      expect(second.first.content).to eq("Content 2")
+
+      # Queryable via count
+      expect(fresh_store.count(model: IntegrationTestModels::TestDocument)).to eq(2)
+    end
+  end
+
+  describe "statistics" do
+    let(:store) { Lutaml::Store.new(adapter: :memory, models: [doc_model]) }
+
+    it "reports registered models and counts" do
+      store.save(IntegrationTestModels::TestDocument.new(id: "doc1", title: "Test"))
+
+      stats = store.stats
+      expect(stats[:models_registered]).to eq(1)
+      expect(stats[:total_models]).to eq(1)
+      expect(stats[:registered_models]).to include("IntegrationTestModels::TestDocument")
+    end
+  end
+end

data/spec/lutaml/store/model_serializer_spec.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module ModelSerializerTestModels
+  class SerialBook < Lutaml::Model::Serializable
+    attribute :isbn, :string
+    attribute :title, :string
+    attribute :author, :string
+  end
+
+  class SerialEbook < SerialBook
+    attribute :format, :string
+  end
+end
+
+RSpec.describe Lutaml::Store::ModelSerializer do
+  subject(:serializer) { described_class.new }
+
+  describe "#serialize" do
+    it "serializes a model to a hash with class metadata" do
+      book = ModelSerializerTestModels::SerialBook.new(isbn: "978-123", title: "Test Book", author: "Author")
+      result = serializer.serialize(book)
+
+      expect(result).to be_a(Hash)
+      expect(result["_class"]).to eq("ModelSerializerTestModels::SerialBook")
+      expect(result["isbn"]).to eq("978-123")
+      expect(result["title"]).to eq("Test Book")
+      expect(result["author"]).to eq("Author")
+    end
+
+    it "serializes a subclass with correct class name" do
+      ebook = ModelSerializerTestModels::SerialEbook.new(isbn: "978-456", title: "Digital Book", format: "epub")
+      result = serializer.serialize(ebook)
+
+      expect(result["_class"]).to eq("ModelSerializerTestModels::SerialEbook")
+      expect(result["format"]).to eq("epub")
+    end
+  end
+
+  describe "#deserialize" do
+    it "deserializes a hash to the correct model class" do
+      data = {
+        "_class" => "ModelSerializerTestModels::SerialBook",
+        "isbn" => "978-123",
+        "title" => "Test Book",
+        "author" => "Author"
+      }
+
+      result = serializer.deserialize(data, ModelSerializerTestModels::SerialBook)
+
+      expect(result).to be_a(ModelSerializerTestModels::SerialBook)
+      expect(result.isbn).to eq("978-123")
+      expect(result.title).to eq("Test Book")
+    end
+
+    it "deserializes to a subclass when class metadata indicates it" do
+      data = {
+        "_class" => "ModelSerializerTestModels::SerialEbook",
+        "isbn" => "978-456",
+        "title" => "Digital",
+        "format" => "epub"
+      }
+
+      result = serializer.deserialize(data, ModelSerializerTestModels::SerialBook)
+
+      expect(result).to be_a(ModelSerializerTestModels::SerialEbook)
+      expect(result.format).to eq("epub")
+    end
+
+    it "rejects incompatible polymorphic types" do
+      data = {
+        "_class" => "ModelSerializerTestModels::SerialBook",
+        "isbn" => "978-123"
+      }
+
+      expect do
+        serializer.deserialize(data, ModelSerializerTestModels::SerialEbook)
+      end.to raise_error(Lutaml::Store::PolymorphicUpdateError, /not compatible/)
+    end
+
+    it "raises on invalid data (missing _class)" do
+      data = { "isbn" => "978-123" }
+
+      expect do
+        serializer.deserialize(data, ModelSerializerTestModels::SerialBook)
+      end.to raise_error(Lutaml::Store::CompositeModelError, /Invalid serialized data/)
+    end
+
+    it "raises on invalid data (not a Hash)" do
+      expect do
+        serializer.deserialize("not a hash", ModelSerializerTestModels::SerialBook)
+      end.to raise_error(Lutaml::Store::CompositeModelError, /Invalid serialized data/)
+    end
+
+    it "raises on unresolvable class name" do
+      data = { "_class" => "NonExistentClass", "isbn" => "123" }
+
+      expect do
+        serializer.deserialize(data, ModelSerializerTestModels::SerialBook)
+      end.to raise_error(Lutaml::Store::CompositeModelError, /Cannot resolve class/)
+    end
+
+    it "strips internal metadata keys from model data" do
+      data = {
+        "_class" => "ModelSerializerTestModels::SerialBook",
+        "_composite_models" => { "studio" => { "storage_key" => "key1" } },
+        "isbn" => "978-123",
+        "title" => "Test"
+      }
+
+      result = serializer.deserialize(data, ModelSerializerTestModels::SerialBook)
+
+      expect(result.isbn).to eq("978-123")
+      expect(result.title).to eq("Test")
+    end
+  end
+
+  describe "round-trip" do
+    it "serializes and deserializes preserving all attributes" do
+      book = ModelSerializerTestModels::SerialBook.new(isbn: "978-789", title: "Round Trip", author: "Traveler")
+      serialized = serializer.serialize(book)
+      deserialized = serializer.deserialize(serialized, ModelSerializerTestModels::SerialBook)
+
+      expect(deserialized.isbn).to eq("978-789")
+      expect(deserialized.title).to eq("Round Trip")
+      expect(deserialized.author).to eq("Traveler")
+    end
+
+    it "preserves subclass identity through round-trip" do
+      ebook = ModelSerializerTestModels::SerialEbook.new(isbn: "978-000", title: "E-Book", author: "Digital",
+                                                         format: "mobi")
+      serialized = serializer.serialize(ebook)
+      deserialized = serializer.deserialize(serialized, ModelSerializerTestModels::SerialBook)
+
+      expect(deserialized).to be_a(ModelSerializerTestModels::SerialEbook)
+      expect(deserialized.format).to eq("mobi")
+    end
+  end
+end

data/spec/lutaml/store/store_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store::BasicStore do
+  let(:store) { described_class.new }
+
+  describe "initialization" do
+    it "creates a store with default memory adapter" do
+      expect(store.adapter).to be_a(Lutaml::Store::Adapter::Memory)
+    end
+
+    it "creates a store with configuration hash" do
+      config = {
+        "adapter" => { "type" => "memory" },
+        "cache" => { "enabled" => false }
+      }
+      store = described_class.new(config)
+      expect(store.cache).to be_nil
+    end
+
+    it "creates a store with direct adapter instance" do
+      adapter = Lutaml::Store::Adapter::Memory.new
+      store = described_class.new(adapter)
+      expect(store.adapter).to eq(adapter)
+    end
+  end
+
+  describe "basic operations" do
+    it "stores and retrieves values" do
+      store.set("key1", "value1")
+      expect(store.get("key1")).to eq("value1")
+    end
+
+    it "returns nil for non-existent keys" do
+      expect(store.get("nonexistent")).to be_nil
+    end
+
+    it "deletes values" do
+      store.set("key1", "value1")
+      expect(store.delete("key1")).to be true
+      expect(store.get("key1")).to be_nil
+    end
+
+    it "checks key existence" do
+      store.set("key1", "value1")
+      expect(store.exists?("key1")).to be true
+      expect(store.exists?("nonexistent")).to be false
+    end
+
+    it "returns all data" do
+      store.set("key1", "value1")
+      store.set("key2", "value2")
+      expect(store.all).to eq("key1" => "value1", "key2" => "value2")
+    end
+
+    it "clears all data" do
+      store.set("key1", "value1")
+      store.clear
+      expect(store.size).to eq(0)
+    end
+
+    it "returns correct size" do
+      expect(store.size).to eq(0)
+      store.set("key1", "value1")
+      expect(store.size).to eq(1)
+    end
+  end
+
+  describe "caching" do
+    let(:config) do
+      {
+        "adapter" => { "type" => "memory" },
+        "cache" => { "enabled" => true, "max_size" => 10 }
+      }
+    end
+    let(:store) { described_class.new(config) }
+
+    it "caches retrieved values" do
+      store.set("key1", "value1")
+
+      # First get should hit backend
+      value1 = store.get("key1")
+      expect(value1).to eq("value1")
+
+      # Second get should hit cache
+      value2 = store.get("key1")
+      expect(value2).to eq("value1")
+
+      # Cache should contain the value
+      expect(store.cache_stats[:size]).to eq(1)
+    end
+
+    it "invalidates cache on delete" do
+      store.set("key1", "value1")
+      store.get("key1") # Cache the value
+
+      store.delete("key1")
+      expect(store.cache_stats[:size]).to eq(0)
+    end
+  end
+
+  describe "events" do
+    let(:events) { [] }
+
+    before do
+      store.on(:set) { |data| events << data }
+      store.on(:get) { |data| events << data }
+      store.on(:delete) { |data| events << data }
+    end
+
+    it "emits events for operations" do
+      store.set("key1", "value1")
+      store.get("key1")
+      store.delete("key1")
+
+      expect(events.size).to eq(3)
+      expect(events[0][:event]).to eq(:set)
+      expect(events[1][:event]).to eq(:get)
+      expect(events[2][:event]).to eq(:delete)
+    end
+  end
+
+  describe "monitoring" do
+    let(:config) do
+      {
+        "adapter" => { "type" => "memory" },
+        "monitoring" => { "enabled" => true }
+      }
+    end
+    let(:store) { described_class.new(config) }
+
+    it "tracks operation statistics" do
+      store.set("key1", "value1")
+      store.get("key1")
+
+      stats = store.stats
+      monitor_stats = stats[:monitor_stats]
+      expect(monitor_stats[:operations][:set]).to eq(1)
+      expect(monitor_stats[:operations][:get]).to eq(1)
+      # NOTE: total_operations includes the size call from stats method
+      expect(monitor_stats[:total_operations]).to be >= 2
+    end
+  end
+
+  describe "configuration from file" do
+    let(:config_file) { "test_config.yml" }
+    let(:config_content) do
+      <<~YAML
+        lutaml_store:
+          adapter:
+            type: memory
+          cache:
+            enabled: true
+            max_size: 500
+          monitoring:
+            enabled: true
+      YAML
+    end
+
+    before do
+      File.write(config_file, config_content)
+    end
+
+    after do
+      File.delete(config_file) if File.exist?(config_file)
+    end
+
+    it "loads configuration from YAML file" do
+      store = described_class.from_file(config_file)
+      expect(store.adapter).to be_a(Lutaml::Store::Adapter::Memory)
+      expect(store.cache).not_to be_nil
+      expect(store.monitor).not_to be_nil
+    end
+  end
+
+  describe "#close" do
+    it "closes resources properly" do
+      expect { store.close }.not_to raise_error
+    end
+  end
+end

data/spec/lutaml/store_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+RSpec.describe Lutaml::Store do
+  it "has a version number" do
+    expect(Lutaml::Store::VERSION).not_to be nil
+  end
+
+  it "provides access to Store and DatabaseStore classes" do
+    expect(Lutaml::Store::BasicStore).to be_a(Class)
+    expect(Lutaml::Store::DatabaseStore).to be_a(Class)
+  end
+
+  it "returns a DatabaseStore from .new" do
+    test_model = Struct.new(:id, :name)
+    store = Lutaml::Store.new(
+      adapter: :memory,
+      models: [{ model: test_model, key: :id }]
+    )
+    expect(store).to be_a(Lutaml::Store::DatabaseStore)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+require "lutaml/store"
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end