lutaml-store 0.2.0 → 0.2.1

data/spec/lutaml/store/lutaml_model_integration_spec.rb

@@ -1,291 +0,0 @@
-# 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

@@ -1,140 +0,0 @@
-# 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/package_definition_spec.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "support/simple_test_model"
-require "support/yamls_test_model"
-
-RSpec.describe Lutaml::Store::PackageDefinition do
-  subject(:definition) do
-    described_class.new(
-      name: :test,
-      metadata_model: SimpleTestModel,
-      metadata_file: "meta.yaml"
-    ) do |pkg|
-      pkg.model(model: YamlsTestModel, dir: "items",
-                layout: :separate, key: :id, default_format: :yamls)
-      pkg.model(model: SimpleTestModel, file: "config.yaml",
-                key: :id, default_format: :yaml)
-      pkg.asset("images", type: :directory)
-      pkg.asset("readme.txt", type: :file)
-    end
-  end
-
-  it "stores name" do
-    expect(definition.name).to eq(:test)
-  end
-
-  it "stores metadata model and file" do
-    expect(definition.metadata_model).to eq(SimpleTestModel)
-    expect(definition.metadata_file).to eq("meta.yaml")
-  end
-
-  it "stores model entries" do
-    expect(definition.model_entries.length).to eq(2)
-
-    yamls_entry = definition.model_entries.first
-    expect(yamls_entry.model).to eq(YamlsTestModel)
-    expect(yamls_entry.dir).to eq("items")
-    expect(yamls_entry.layout).to eq(:separate)
-    expect(yamls_entry.key).to eq(:id)
-    expect(yamls_entry.default_format).to eq(:yamls)
-
-    simple_entry = definition.model_entries.last
-    expect(simple_entry.model).to eq(SimpleTestModel)
-    expect(simple_entry.file).to eq("config.yaml")
-  end
-
-  it "stores asset entries" do
-    expect(definition.asset_entries.length).to eq(2)
-    expect(definition.asset_entries[0].path).to eq("images")
-    expect(definition.asset_entries[0].type).to eq(:directory)
-    expect(definition.asset_entries[1].path).to eq("readme.txt")
-    expect(definition.asset_entries[1].type).to eq(:file)
-  end
-
-  describe "dir/file mutual exclusivity" do
-    it "raises when both dir and file are specified" do
-      expect do
-        definition.model(model: SimpleTestModel, dir: "d", file: "f.yaml", key: :id)
-      end.to raise_error(ArgumentError, /Specify dir: or file:, not both/)
-    end
-  end
-
-  describe "#entry_for" do
-    it "finds entry by model class" do
-      entry = definition.entry_for(YamlsTestModel)
-      expect(entry).not_to be_nil
-      expect(entry.dir).to eq("items")
-    end
-
-    it "returns nil for unknown model" do
-      expect(definition.entry_for(String)).to be_nil
-    end
-  end
-
-  describe "#model_classes" do
-    it "returns registered model classes" do
-      expect(definition.model_classes).to contain_exactly(YamlsTestModel, SimpleTestModel)
-    end
-  end
-
-  describe "#database_store_models" do
-    it "includes model entries only (metadata is stored separately)" do
-      configs = definition.database_store_models
-      expect(configs.length).to eq(2) # 2 model entries, no metadata
-      models = configs.map { |c| c[:model] }
-      expect(models).to contain_exactly(YamlsTestModel, SimpleTestModel)
-    end
-  end
-end

data/spec/lutaml/store/package_store_spec.rb

@@ -1,153 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-require "support/simple_test_model"
-require "support/yamls_test_model"
-
-RSpec.describe Lutaml::Store::PackageStore do
-  let(:definition) do
-    Lutaml::Store::PackageDefinition.new(name: :test) do |pkg|
-      pkg.model(model: SimpleTestModel, dir: "items",
-                layout: :separate, key: :id, default_format: :yaml)
-    end
-  end
-
-  let(:store) { described_class.new(definition) }
-
-  describe "#add_model / #models_for" do
-    it "stores and retrieves model instances" do
-      model = SimpleTestModel.new(id: "test-1", name: "Test")
-      store.add_model(model)
-      expect(store.models_for(SimpleTestModel)).to include(model)
-    end
-
-    it "stores multiple instances" do
-      3.times { |i| store.add_model(SimpleTestModel.new(id: "test-#{i}")) }
-      expect(store.model_count(SimpleTestModel)).to eq(3)
-    end
-  end
-
-  describe "#fetch_model" do
-    it "retrieves by key" do
-      model = SimpleTestModel.new(id: "abc", name: "ABC")
-      store.add_model(model)
-      expect(store.fetch_model(SimpleTestModel, "abc").name).to eq("ABC")
-    end
-
-    it "returns nil for missing key" do
-      expect(store.fetch_model(SimpleTestModel, "missing")).to be_nil
-    end
-  end
-
-  describe "#model_exists?" do
-    it "returns true for existing key" do
-      store.add_model(SimpleTestModel.new(id: "exists"))
-      expect(store.model_exists?(SimpleTestModel, "exists")).to be true
-    end
-
-    it "returns false for missing key" do
-      expect(store.model_exists?(SimpleTestModel, "missing")).to be false
-    end
-  end
-
-  describe "#remove_model" do
-    it "removes by key" do
-      store.add_model(SimpleTestModel.new(id: "remove-me"))
-      store.remove_model(SimpleTestModel, "remove-me")
-      expect(store.model_exists?(SimpleTestModel, "remove-me")).to be false
-    end
-  end
-
-  describe "#metadata=" do
-    let(:def_with_metadata) do
-      Lutaml::Store::PackageDefinition.new(
-        name: :test, metadata_model: SimpleTestModel,
-        metadata_file: "meta.yaml", metadata_key: :id
-      ) do |pkg|
-        pkg.model(model: SimpleTestModel, dir: "items",
-                  layout: :separate, key: :id, default_format: :yaml)
-      end
-    end
-
-    it "stores metadata" do
-      store = described_class.new(def_with_metadata)
-      store.metadata = SimpleTestModel.new(id: "meta", name: "Metadata")
-      expect(store.metadata.name).to eq("Metadata")
-    end
-  end
-
-  describe "#add_asset / #asset" do
-    it "stores and retrieves raw content" do
-      store.add_asset("images/logo.png", "PNG_DATA")
-      expect(store.asset("images/logo.png")).to eq("PNG_DATA")
-    end
-
-    it "lists asset paths" do
-      store.add_asset("a.txt", "A")
-      store.add_asset("b.txt", "B")
-      expect(store.asset_paths).to contain_exactly("a.txt", "b.txt")
-    end
-  end
-
-  describe "#remove_asset" do
-    it "removes an asset" do
-      store.add_asset("remove.txt", "data")
-      store.remove_asset("remove.txt")
-      expect(store.asset("remove.txt")).to be_nil
-    end
-  end
-
-  describe "#clear_all" do
-    it "removes everything" do
-      store.add_model(SimpleTestModel.new(id: "x"))
-      store.add_asset("file.txt", "data")
-      store.clear_all
-      expect(store.model_count(SimpleTestModel)).to eq(0)
-      expect(store.asset_paths).to be_empty
-    end
-  end
-
-  describe "#stats" do
-    it "reports model counts and asset count" do
-      store.add_model(SimpleTestModel.new(id: "1"))
-      store.add_asset("f.txt", "x")
-      stats = store.stats
-      expect(stats[:package]).to eq(:test)
-      expect(stats[:models][SimpleTestModel.name]).to eq(1)
-      expect(stats[:assets]).to eq(1)
-    end
-  end
-
-  describe "#resolve_formats" do
-    let(:def_with_two) do
-      Lutaml::Store::PackageDefinition.new(name: :test) do |pkg|
-        pkg.model(model: SimpleTestModel, dir: "a", key: :id, default_format: :yaml)
-        pkg.model(model: SimpleTestModel, dir: "b", key: :id, default_format: :yamls)
-      end
-    end
-
-    let(:two_model_store) { described_class.new(def_with_two) }
-
-    it "global format overrides all models" do
-      formats = two_model_store.send(:resolve_formats, :json, {})
-      expect(formats[SimpleTestModel]).to eq(:json)
-    end
-
-    it "per-model format overrides specific models" do
-      formats = two_model_store.send(:resolve_formats, nil,
-                                     { SimpleTestModel => :marshal })
-      expect(formats[SimpleTestModel]).to eq(:marshal)
-    end
-
-    it "both: global + per-model merge" do
-      formats = two_model_store.send(:resolve_formats, :json,
-                                     { SimpleTestModel => :marshal })
-      expect(formats[SimpleTestModel]).to eq(:marshal)
-    end
-
-    it "nil: use defaults (empty hash)" do
-      formats = two_model_store.send(:resolve_formats, nil, {})
-      expect(formats).to be_empty
-    end
-  end
-end