lutaml-store 0.1.1

data/spec/lutaml/store/import_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+class ImportTestItem < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :category, :string
+
+  key_value do
+    map :name, to: :name
+    map :category, to: :category
+  end
+end
+
+RSpec.describe "Lutaml::Store import workflow" do
+  let(:tmpdir) { Dir.mktmpdir }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  let(:store) do
+    Lutaml::Store.new(
+      adapter: :memory,
+      models: [{ model: ImportTestItem, key: :name, dir: "items" }]
+    )
+  end
+
+  let(:items) do
+    [
+      ImportTestItem.new(name: "alpha", category: "primary"),
+      ImportTestItem.new(name: "beta", category: "secondary"),
+      ImportTestItem.new(name: "gamma", category: "primary")
+    ]
+  end
+
+  describe "#import_all" do
+    before do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
+    end
+
+    it "loads from directory and stores into key-value backend" do
+      fresh_store = Lutaml::Store.new(
+        adapter: :memory,
+        models: [{ model: ImportTestItem, key: :name, dir: "items" }]
+      )
+
+      loaded = fresh_store.import_all(ImportTestItem, path: tmpdir, format: :yaml, layout: :separate)
+      expect(loaded.size).to eq(3)
+
+      # Now queryable via fetch
+      fetched = fresh_store.fetch(model: ImportTestItem, name: "alpha")
+      expect(fetched).not_to be_nil
+      expect(fetched.name).to eq("alpha")
+      expect(fetched.category).to eq("primary")
+    end
+
+    it "supports where queries after import" do
+      fresh_store = Lutaml::Store.new(
+        adapter: :memory,
+        models: [{ model: ImportTestItem, key: :name, dir: "items" }]
+      )
+
+      fresh_store.import_all(ImportTestItem, path: tmpdir, format: :yaml, layout: :separate)
+
+      primary = fresh_store.where(model: ImportTestItem, category: "primary")
+      expect(primary.size).to eq(2)
+      expect(primary.map(&:name).sort).to eq(%w[alpha gamma])
+    end
+
+    it "supports count after import" do
+      fresh_store = Lutaml::Store.new(
+        adapter: :memory,
+        models: [{ model: ImportTestItem, key: :name, dir: "items" }]
+      )
+
+      fresh_store.import_all(ImportTestItem, path: tmpdir, format: :yaml, layout: :separate)
+      expect(fresh_store.count(model: ImportTestItem)).to eq(3)
+    end
+
+    it "supports exists? after import" do
+      fresh_store = Lutaml::Store.new(
+        adapter: :memory,
+        models: [{ model: ImportTestItem, key: :name, dir: "items" }]
+      )
+
+      fresh_store.import_all(ImportTestItem, path: tmpdir, format: :yaml, layout: :separate)
+      expect(fresh_store.exists?(model: ImportTestItem, name: "beta")).to be true
+      expect(fresh_store.exists?(model: ImportTestItem, name: "missing")).to be false
+    end
+  end
+end

data/spec/lutaml/store/integrity_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Store::Integrity do
+  describe ".calculate_checksum" do
+    let(:test_data) { "Hello, World!" }
+
+    it "calculates SHA256 checksum by default" do
+      checksum = described_class.calculate_checksum(test_data)
+      expect(checksum).to eq(Digest::SHA256.hexdigest(test_data))
+    end
+
+    it "calculates MD5 checksum" do
+      checksum = described_class.calculate_checksum(test_data, "md5")
+      expect(checksum).to eq(Digest::MD5.hexdigest(test_data))
+    end
+
+    it "calculates SHA1 checksum" do
+      checksum = described_class.calculate_checksum(test_data, "sha1")
+      expect(checksum).to eq(Digest::SHA1.hexdigest(test_data))
+    end
+
+    it "raises error for unsupported algorithm" do
+      expect do
+        described_class.calculate_checksum(test_data, "unsupported")
+      end.to raise_error(ArgumentError, /Unsupported checksum algorithm/)
+    end
+  end
+
+  describe ".verify_checksum" do
+    let(:test_data) { "Hello, World!" }
+    let(:correct_checksum) { Digest::SHA256.hexdigest(test_data) }
+    let(:incorrect_checksum) { "incorrect" }
+
+    it "returns true for correct checksum" do
+      expect(described_class.verify_checksum(test_data, correct_checksum)).to be true
+    end
+
+    it "raises ChecksumMismatchError for incorrect checksum" do
+      expect do
+        described_class.verify_checksum(test_data, incorrect_checksum)
+      end.to raise_error(Lutaml::Store::Integrity::ChecksumMismatchError)
+    end
+  end
+
+  describe ".create_integrity_metadata" do
+    let(:test_data) { "Hello, World!" }
+
+    it "creates integrity metadata with checksum and size" do
+      metadata = described_class.create_integrity_metadata(test_data)
+
+      expect(metadata).to have_key(:checksum)
+      expect(metadata).to have_key(:algorithm)
+      expect(metadata).to have_key(:size)
+      expect(metadata).to have_key(:created_at)
+      expect(metadata).to have_key(:version)
+
+      expect(metadata[:checksum]).to eq(Digest::SHA256.hexdigest(test_data))
+      expect(metadata[:algorithm]).to eq("sha256")
+      expect(metadata[:size]).to eq(test_data.bytesize)
+      expect(metadata[:version]).to eq("1.0")
+    end
+
+    it "uses specified algorithm" do
+      metadata = described_class.create_integrity_metadata(test_data, "md5")
+
+      expect(metadata[:checksum]).to eq(Digest::MD5.hexdigest(test_data))
+      expect(metadata[:algorithm]).to eq("md5")
+    end
+  end
+
+  describe ".verify_integrity_metadata" do
+    let(:test_data) { "Hello, World!" }
+    let(:valid_metadata) do
+      {
+        checksum: Digest::SHA256.hexdigest(test_data),
+        algorithm: "sha256",
+        size: test_data.bytesize
+      }
+    end
+
+    it "returns true for valid metadata" do
+      expect(described_class.verify_integrity_metadata(test_data, valid_metadata)).to be true
+    end
+
+    it "raises CorruptionError for size mismatch" do
+      invalid_metadata = valid_metadata.merge(size: 999)
+
+      expect do
+        described_class.verify_integrity_metadata(test_data, invalid_metadata)
+      end.to raise_error(Lutaml::Store::Integrity::CorruptionError, /Size mismatch/)
+    end
+
+    it "raises ChecksumMismatchError for checksum mismatch" do
+      invalid_metadata = valid_metadata.merge(checksum: "invalid")
+
+      expect do
+        described_class.verify_integrity_metadata(test_data, invalid_metadata)
+      end.to raise_error(Lutaml::Store::Integrity::ChecksumMismatchError)
+    end
+
+    it "returns true when no integrity metadata is present" do
+      expect(described_class.verify_integrity_metadata(test_data, {})).to be true
+    end
+  end
+
+  describe ".repair_data" do
+    let(:corrupted_data) { "Hello, Wor\x00ld!" }
+    let(:backup_data) { "Hello, World!" }
+
+    it "returns backup data if available and valid" do
+      repaired = described_class.repair_data(corrupted_data, backup_data)
+      expect(repaired).to eq(backup_data)
+    end
+
+    it "attempts to clean corrupted data" do
+      repaired = described_class.repair_data(corrupted_data)
+      expect(repaired).to eq("Hello, World!")
+    end
+
+    it "fixes truncated JSON" do
+      corrupted_json = '{"key": "value"'
+      repaired = described_class.repair_data(corrupted_json)
+      expect(repaired).to eq('{"key": "value"}')
+    end
+
+    it "fixes truncated arrays" do
+      corrupted_array = '["item1", "item2"'
+      repaired = described_class.repair_data(corrupted_array)
+      expect(repaired).to eq('["item1", "item2"]')
+    end
+  end
+
+  describe ".valid_data?" do
+    it "returns true for valid UTF-8 string" do
+      expect(described_class.valid_data?("Hello, World!")).to be true
+    end
+
+    it "returns false for nil data" do
+      expect(described_class.valid_data?(nil)).to be false
+    end
+
+    it "returns false for empty data" do
+      expect(described_class.valid_data?("")).to be false
+    end
+
+    it "returns false for data with null bytes" do
+      expect(described_class.valid_data?("Hello\x00World")).to be false
+    end
+
+    it "returns true for binary data" do
+      binary_data = "\xFF\xFE\xFD".dup.force_encoding("ASCII-8BIT")
+      expect(described_class.valid_data?(binary_data)).to be true
+    end
+  end
+end

data/spec/lutaml/store/key_collision_serializer_spec.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Model with a key collision: both id and code serialize to the same "id" key.
+# Demonstrates the custom serializer pattern for preserving all fields.
+class CollisionItem < Lutaml::Model::Serializable
+  attribute :id, :string
+  attribute :code, :string
+  attribute :label, :string
+
+  key_value do
+    map :id, to: :id
+    map :code, with: { to: :code_to_yaml, from: :code_from_yaml }
+    map :label, to: :label
+  end
+
+  def code_to_yaml(model, doc)
+    doc["id"] = model.code if model.code
+  end
+
+  def code_from_yaml(model, value)
+    model.code = value if value
+  end
+end
+
+class CollisionSerializer < Lutaml::Store::ModelSerializer
+  def serialize(model, _registration = nil)
+    {
+      "_yaml" => model.to_yaml,
+      "_id" => model.id,
+      "_code" => model.code
+    }
+  end
+
+  def deserialize(data, expected_class, _registration = nil)
+    model = expected_class.from_yaml(data["_yaml"])
+    model.id = data["_id"]
+    model.code = data["_code"]
+    model
+  end
+end
+
+RSpec.describe "Custom serializer with key collision workaround" do
+  let(:store) do
+    Lutaml::Store.new(
+      adapter: :memory,
+      models: [{
+        model: CollisionItem,
+        key: :id,
+        serializer: CollisionSerializer.new
+      }]
+    )
+  end
+
+  it "preserves both id and code through save/fetch" do
+    item = CollisionItem.new(id: "item-1", code: "CODE-1", label: "First item")
+    store.save(item)
+
+    fetched = store.fetch(model: CollisionItem, id: "item-1")
+    expect(fetched.id).to eq("item-1")
+    expect(fetched.code).to eq("CODE-1")
+    expect(fetched.label).to eq("First item")
+  end
+
+  it "preserves fields through update" do
+    item = CollisionItem.new(id: "item-2", code: "CODE-2", label: "Original")
+    store.save(item)
+
+    updated = store.update(model: CollisionItem, id: "item-2", attributes: { label: "Updated" })
+    expect(updated.id).to eq("item-2")
+    expect(updated.code).to eq("CODE-2")
+    expect(updated.label).to eq("Updated")
+  end
+
+  it "preserves fields through where query" do
+    store.save(CollisionItem.new(id: "a1", code: "C1", label: "One"))
+    store.save(CollisionItem.new(id: "a2", code: "C2", label: "Two"))
+
+    found = store.where(model: CollisionItem, code: "C1")
+    expect(found.size).to eq(1)
+    expect(found.first.id).to eq("a1")
+    expect(found.first.code).to eq("C1")
+  end
+
+  it "lists all items with correct fields" do
+    3.times do |i|
+      store.save(CollisionItem.new(id: "x-#{i}", code: "C-#{i}", label: "Item #{i}"))
+    end
+
+    all = store.all(model: CollisionItem)
+    expect(all.size).to eq(3)
+    all.each do |item|
+      expect(item.id).to start_with("x-")
+      expect(item.code).to start_with("C-")
+    end
+  end
+end

data/spec/lutaml/store/load_save_spec.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+# Test model using lutaml-model
+class TestItem < Lutaml::Model::Serializable
+  attribute :name, :string
+  attribute :value, :string
+
+  key_value do
+    map :name, to: :name
+    map :value, to: :value
+  end
+end
+
+RSpec.describe "Lutaml::Store load_all / save_all" do
+  let(:tmpdir) { Dir.mktmpdir }
+  after { FileUtils.rm_rf(tmpdir) }
+
+  let(:store) do
+    Lutaml::Store.new(
+      adapter: :memory,
+      models: [{ model: TestItem, key: :name, dir: "items" }]
+    )
+  end
+
+  let(:items) do
+    [
+      TestItem.new(name: "alpha", value: "first"),
+      TestItem.new(name: "beta", value: "second"),
+      TestItem.new(name: "gamma", value: "third")
+    ]
+  end
+
+  describe "#save_all with :yaml format" do
+    it "writes YAML files to the model directory" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
+
+      items_dir = File.join(tmpdir, "items")
+      expect(Dir.exist?(items_dir)).to be true
+
+      files = Dir.glob(File.join(items_dir, "*.yaml")).sort
+      expect(files.size).to eq(3)
+
+      content = File.read(files.first, encoding: "utf-8")
+      expect(content).to include("name:")
+      expect(content).to include("value:")
+    end
+  end
+
+  describe "#load_all with :yaml format" do
+    it "round-trips models through YAML files" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :separate)
+
+      loaded = store.load_all(TestItem, path: tmpdir, format: :yaml, layout: :separate)
+
+      expect(loaded.size).to eq(3)
+      names = loaded.map(&:name).sort
+      expect(names).to eq(%w[alpha beta gamma])
+      values = loaded.map(&:value).sort
+      expect(values).to eq(%w[first second third])
+    end
+  end
+
+  describe "#save_all with :grouped layout" do
+    it "writes one file per key" do
+      store.save_all(items, path: tmpdir, format: :yaml, layout: :grouped)
+
+      items_dir = File.join(tmpdir, "items")
+      files = Dir.glob(File.join(items_dir, "*.yaml")).sort
+      expect(files.size).to eq(3)
+    end
+  end
+
+  describe "#save_all with :json format" do
+    it "writes JSON files" do
+      store.save_all(items, path: tmpdir, format: :json, layout: :separate)
+
+      items_dir = File.join(tmpdir, "items")
+      files = Dir.glob(File.join(items_dir, "*.json")).sort
+      expect(files.size).to eq(3)
+
+      content = File.read(files.first, encoding: "utf-8")
+      expect(content).to include('"name"')
+    end
+  end
+
+  describe "#export" do
+    it "exports all models to a single file" do
+      export_path = File.join(tmpdir, "export.jsonl")
+      store.export(items, path: export_path, format: :jsonl)
+
+      expect(File.exist?(export_path)).to be true
+      content = File.read(export_path, encoding: "utf-8")
+      lines = content.lines.reject(&:empty?)
+      expect(lines.size).to eq(3)
+    end
+  end
+
+  describe "empty model list" do
+    it "returns empty array for save_all" do
+      result = store.save_all([], path: tmpdir, format: :yaml, layout: :separate)
+      expect(result).to eq([])
+    end
+  end
+end