lutaml-model 0.8.3 → 0.8.4

data/spec/lutaml/model/validation/remediation_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Remediation do
+  subject(:remediation) { described_class.new }
+
+  it "returns nil id by default" do
+    expect(remediation.id).to be_nil
+  end
+
+  it "returns nil targets by default" do
+    expect(remediation.targets).to be_nil
+  end
+
+  it "is always applicable" do
+    expect(remediation.applicable?(nil, nil)).to be true
+  end
+
+  it "raises NotImplementedError from base fix" do
+    expect { remediation.fix(nil, nil) }
+      .to raise_error(NotImplementedError, /must be implemented/)
+  end
+
+  it "returns nil preview by default" do
+    expect(remediation.preview(nil, nil)).to be_nil
+  end
+
+  describe "custom subclass" do
+    let(:custom_remediation) do
+      Class.new(described_class) do
+        def id = "REM-001"
+        def targets = ["DOC-020"]
+
+        def applicable?(_context, report)
+          report.any? { |i| i.code == "DOC-020" }
+        end
+
+        def fix(_context, _report)
+          Lutaml::Model::Validation::RemediationResult.new(
+            success: true,
+            message: "Fixed DOC-020",
+            fixed_codes: ["DOC-020"],
+          )
+        end
+      end
+    end
+
+    it "overrides id and targets" do
+      rem = custom_remediation.new
+      expect(rem.id).to eq("REM-001")
+      expect(rem.targets).to eq(["DOC-020"])
+    end
+
+    it "checks applicability" do
+      rem = custom_remediation.new
+      issue = Lutaml::Model::Validation::Issue.new(
+        severity: "error", code: "DOC-020", message: "bad",
+      )
+      expect(rem.applicable?(nil, [issue])).to be true
+      expect(rem.applicable?(nil, [])).to be false
+    end
+
+    it "returns successful fix" do
+      rem = custom_remediation.new
+      result = rem.fix(nil, nil)
+      expect(result.success).to be true
+      expect(result.fixed_codes).to eq(["DOC-020"])
+    end
+  end
+end

data/spec/lutaml/model/validation/report_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Report do
+  subject(:report) do
+    described_class.new(
+      source: "test.xml",
+      valid: false,
+      duration_ms: 50,
+      layers: [layer],
+    )
+  end
+
+  let(:issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "TEST-003", message: "Broken",
+    )
+  end
+
+  let(:layer) do
+    Lutaml::Model::Validation::LayerResult.new(
+      name: "Check", status: "fail", issues: [issue],
+    )
+  end
+
+  it "serializes to JSON" do
+    parsed = JSON.parse(report.to_json)
+    expect(parsed["source"]).to eq("test.xml")
+    expect(parsed["valid"]).to be(false)
+    expect(parsed["timestamp"]).not_to be_nil
+  end
+
+  it "auto-sets timestamp on initialization" do
+    expect(report.timestamp).to match(/\d{4}-\d{2}-\d{2}T/)
+  end
+
+  describe "issue aggregation via HasIssues" do
+    it "aggregates issues from all layers" do
+      expect(report.issues.length).to eq(1)
+    end
+
+    it "filters errors" do
+      expect(report.errors.length).to eq(1)
+    end
+
+    it "returns empty warnings when none present" do
+      expect(report.warnings).to be_empty
+    end
+  end
+
+  it "handles empty layers" do
+    empty_report = described_class.new(source: "empty.xml", valid: true)
+    expect(empty_report.issues).to be_empty
+    expect(empty_report.errors).to be_empty
+  end
+end

data/spec/lutaml/model/validation/rule_spec.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Rule do
+  subject(:rule) { described_class.new }
+
+  describe "defaults" do
+    it "returns nil code" do
+      expect(rule.code).to be_nil
+    end
+
+    it "returns :general category" do
+      expect(rule.category).to eq(:general)
+    end
+
+    it "returns error severity" do
+      expect(rule.severity).to eq("error")
+    end
+
+    it "is always applicable" do
+      expect(rule.applicable?(nil)).to be true
+      expect(rule.applicable?({})).to be true
+    end
+
+    it "returns empty issues from check" do
+      expect(rule.check(nil)).to eq([])
+    end
+
+    it "is not deferred" do
+      expect(rule.needs_deferred?).to be false
+    end
+
+    it "returns nil from collect" do
+      expect(rule.collect(:element, nil)).to be_nil
+    end
+
+    it "returns empty array from complete" do
+      expect(rule.complete(nil)).to eq([])
+    end
+  end
+
+  describe "custom subclass" do
+    let(:custom_rule_class) do
+      Class.new(described_class) do
+        def code = "CUSTOM-001"
+        def category = :custom
+        def severity = "warning"
+
+        def applicable?(context)
+          context&.dig(:enabled) != false
+        end
+
+        def check(_context)
+          [issue("Found a problem")]
+        end
+      end
+    end
+
+    it "overrides defaults" do
+      rule = custom_rule_class.new
+      expect(rule.code).to eq("CUSTOM-001")
+      expect(rule.category).to eq(:custom)
+      expect(rule.severity).to eq("warning")
+    end
+
+    it "produces issues via helper" do
+      rule = custom_rule_class.new
+      issues = rule.check(nil)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("CUSTOM-001")
+      expect(issues.first.severity).to eq("warning")
+      expect(issues.first.message).to eq("Found a problem")
+    end
+
+    it "respects applicable?" do
+      rule = custom_rule_class.new
+      expect(rule.applicable?({ enabled: true })).to be true
+      expect(rule.applicable?({ enabled: false })).to be false
+    end
+
+    it "allows issue helper to override severity and code" do
+      klass = Class.new(described_class) do
+        def code = "OVERRIDE"
+        def severity = "error"
+
+        def check(_context)
+          [issue("msg", severity: "info", code: "OTHER")]
+        end
+      end
+      issues = klass.new.check(nil)
+      expect(issues.first.severity).to eq("info")
+      expect(issues.first.code).to eq("OTHER")
+    end
+  end
+
+  describe "streaming subclass" do
+    let(:streaming_rule_class) do
+      Class.new(described_class) do
+        def code = "STREAM-001"
+        def needs_deferred? = true
+
+        def collect(element, context)
+          state = context.rule_state(code)
+          state[:items] ||= []
+          state[:items] << element
+        end
+
+        def complete(context)
+          state = context.rule_state(code)
+          return [] unless state[:items]&.any?
+
+          [issue("Collected #{state[:items].length} items")]
+        end
+      end
+    end
+
+    it "signals deferred collection" do
+      rule = streaming_rule_class.new
+      expect(rule.needs_deferred?).to be true
+    end
+
+    it "collects elements and reports in complete" do
+      ctx = Lutaml::Model::Validation::Context.new
+      rule = streaming_rule_class.new
+      rule.collect("item_a", ctx)
+      rule.collect("item_b", ctx)
+      issues = rule.complete(ctx)
+      expect(issues.length).to eq(1)
+      expect(issues.first.message).to eq("Collected 2 items")
+    end
+  end
+end

data/spec/lutaml/model/validation/uninitialized_class_validate_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "Lutaml::Model::Validation with UninitializedClass" do
+  before do
+    stub_const("ValidateWithUninitializedModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :role, :string, values: %w[admin guest], default: -> { "guest" }
+    end)
+  end
+
+  it "does not crash when validating with uninitialized attributes" do
+    model = ValidateWithUninitializedModel.new
+    # name is uninitialized, but validate should not crash
+    expect { model.validate }.not_to raise_error
+  end
+
+  it "still catches value constraint violations" do
+    model = ValidateWithUninitializedModel.new(role: "hacker")
+    errors = model.validate
+    expect(errors).not_to be_empty
+  end
+
+  it "returns empty errors for valid instance" do
+    model = ValidateWithUninitializedModel.new(name: "ok", role: "admin")
+    expect(model.validate).to be_empty
+  end
+end

data/spec/lutaml/model/validation/validation_error_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::ValidationError do
+  it "is a StandardError" do
+    expect(described_class).to be < StandardError
+  end
+
+  it "stores message" do
+    error = described_class.new("Something broke")
+    expect(error.message).to eq("Something broke")
+  end
+
+  it "stores issues" do
+    issue = Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+    error = described_class.new("Failed", issues: [issue])
+    expect(error.issues.length).to eq(1)
+    expect(error.issues.first.code).to eq("E-001")
+  end
+
+  it "defaults issues to empty array" do
+    error = described_class.new("Failed")
+    expect(error.issues).to eq([])
+  end
+end

data/spec/lutaml/model/validation/validation_framework_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation, ".validate / .validate!" do
+  let(:registry) { described_class.new_registry }
+
+  let(:rule_a_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "E2E-001"
+      def severity = "error"
+
+      def check(context)
+        context[:items].empty? ? [issue("No items found")] : []
+      end
+    end
+  end
+
+  let(:rule_b_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "E2E-002"
+      def severity = "warning"
+
+      def check(context)
+        context[:items].length > 100 ? [issue("Too many items")] : []
+      end
+    end
+  end
+
+  before do
+    registry.register(rule_a_class)
+    registry.register(rule_b_class)
+  end
+
+  describe ".validate" do
+    it "finds no issues with valid data" do
+      issues = described_class.validate({ items: (1..50).to_a }, registry)
+      expect(issues).to be_empty
+    end
+
+    it "finds errors for empty items" do
+      issues = described_class.validate({ items: [] }, registry)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("E2E-001")
+      expect(issues.first).to be_error
+    end
+
+    it "finds warnings for too many items" do
+      issues = described_class.validate({ items: (1..101).to_a }, registry)
+      expect(issues.length).to eq(1)
+      expect(issues.first.code).to eq("E2E-002")
+      expect(issues.first).to be_warning
+    end
+
+    it "skips inapplicable rules" do
+      skip_rule = Class.new(Lutaml::Model::Validation::Rule) do
+        def code = "SKIP"
+        def applicable?(_ctx) = false
+        def check(_ctx) = [issue("should not appear")]
+      end
+      registry.register(skip_rule)
+      issues = described_class.validate({ items: [1] }, registry)
+      expect(issues).to be_empty
+    end
+
+    it "does not crash with contexts that support add_error" do
+      Lutaml::Model::Validation::Context.new
+      # Use plain hash for data — rules expect [:items]
+      issues = described_class.validate({ items: [] }, registry)
+      expect(issues.length).to eq(1)
+      # Plain hash doesn't accumulate, but validate still works
+    end
+  end
+
+  describe ".validate!" do
+    it "raises on errors" do
+      expect do
+        described_class.validate!({ items: [] }, registry)
+      end.to raise_error(Lutaml::Model::Validation::ValidationError, /E2E-001/)
+    end
+
+    it "exposes issues on ValidationError" do
+      described_class.validate!({ items: [] }, registry)
+    rescue Lutaml::Model::Validation::ValidationError => e
+      expect(e.issues.length).to eq(1)
+      expect(e.issues.first.code).to eq("E2E-001")
+    end
+
+    it "does not raise when only warnings" do
+      expect do
+        described_class.validate!({ items: (1..101).to_a }, registry)
+      end.not_to raise_error
+    end
+
+    it "does not raise when no issues" do
+      expect do
+        described_class.validate!({ items: (1..50).to_a }, registry)
+      end.not_to raise_error
+    end
+  end
+
+  describe ".new_registry" do
+    it "returns a fresh Registry instance" do
+      reg = described_class.new_registry
+      expect(reg).to be_a(Lutaml::Model::Validation::Registry)
+      expect(reg.size).to eq(0)
+    end
+  end
+end

data/spec/lutaml/xml/content_model_validation_spec.rb

@@ -0,0 +1,157 @@
+# spec/lutaml/xml/content_model_validation_spec.rb
+
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+RSpec.describe "Content model validation" do
+  describe "OrderedContentMappingError" do
+    it "raises when ordered + map_content" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string
+
+          xml do
+            element "test"
+            ordered
+            map_content to: :content
+          end
+
+          def self.name
+            "OrderedWithContentTest"
+          end
+        end
+      end.to raise_error(
+        Lutaml::Model::OrderedContentMappingError,
+        /Element-only content model.*does not support `map_content`/,
+      )
+    end
+
+    it "raises when root with ordered: true and map_content" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string
+
+          xml do
+            root "test", ordered: true
+            map_content to: :content
+          end
+
+          def self.name
+            "RootOrderedWithContentTest"
+          end
+        end
+      end.to raise_error(Lutaml::Model::OrderedContentMappingError)
+    end
+
+    it "does not raise when ordered without map_content" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :child, :string
+
+          xml do
+            element "test"
+            ordered
+            map_element "child", to: :child
+          end
+
+          def self.name
+            "OrderedWithoutContentTest"
+          end
+        end
+      end.not_to raise_error
+    end
+
+    it "does not raise when mixed_content with map_content (collection)" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string, collection: true
+
+          xml do
+            element "test"
+            mixed_content
+            map_content to: :content
+          end
+
+          def self.name
+            "MixedWithContentTest"
+          end
+        end
+      end.not_to raise_error
+    end
+
+    it "does not raise when root with mixed: true and map_content (collection)" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string, collection: true
+
+          xml do
+            root "test", mixed: true
+            map_content to: :content
+          end
+
+          def self.name
+            "RootMixedWithContentTest"
+          end
+        end
+      end.not_to raise_error
+    end
+
+    it "does not raise when default (no ordered/mixed) with map_content" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string
+
+          xml do
+            element "test"
+            map_content to: :content
+          end
+
+          def self.name
+            "DefaultWithContentTest"
+          end
+        end
+      end.not_to raise_error
+    end
+  end
+
+  describe "MixedContentCollectionError" do
+    it "raises when mixed_content + map_content to non-collection attribute" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string
+
+          xml do
+            element "test"
+            mixed_content
+            map_content to: :content
+          end
+
+          def self.name
+            "MixedContentNonCollectionTest"
+          end
+        end
+      end.to raise_error(
+        Lutaml::Model::MixedContentCollectionError,
+        /Mixed content requires.*to be a string collection/,
+      )
+    end
+
+    it "does not raise when mixed_content + map_content to collection attribute" do
+      expect do
+        Class.new(Lutaml::Model::Serializable) do
+          attribute :content, :string, collection: true
+
+          xml do
+            element "test"
+            mixed_content
+            map_content to: :content
+          end
+
+          def self.name
+            "MixedContentCollectionTest"
+          end
+        end
+      end.not_to raise_error
+    end
+  end
+end

data/spec/lutaml/xml/mapping_spec.rb

@@ -755,15 +755,20 @@ RSpec.describe Lutaml::Xml::Mapping do
       end
 
       it "element_order should be correct" do
-        expect(parsed.element_order).to eq(expected_order)
+        # Filter out whitespace-only text nodes for comparison with expected_order
+        non_ws_order = parsed.element_order.reject do |e|
+          e.type == "Text" && e.text_content&.strip&.empty?
+        end
+        expect(non_ws_order).to eq(expected_order)
       end
 
-      it "element_order omits whitespace-only text nodes" do
-        # Moxml's Nokogiri adapter filters whitespace-only text nodes between
-        # elements, matching the behavior of Oga/Ox/Rexml adapters. This test
-        # locks in that behavior so a regression is detected if moxml changes.
-        text_entries = parsed.element_order.select { |e| e.type == "Text" }
-        expect(text_entries).to be_empty
+      it "element_order includes whitespace-only text nodes" do
+        # Whitespace-only text nodes between elements are preserved in element_order
+        # for mixed-content round-trip fidelity.
+        text_entries = parsed.element_order.select do |e|
+          e.type == "Text" && e.text_content&.strip&.empty?
+        end
+        expect(text_entries).not_to be_empty
       end
 
       it "to_xml should be correct" do