lutaml-model 0.8.3 → 0.8.5

data/spec/lutaml/model/validation/concerns/has_issues_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::HasIssues do
+  let(:error_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+  end
+
+  let(:warning_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "warning", code: "W-001", message: "meh",
+    )
+  end
+
+  let(:info_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "info", code: "I-001", message: "fyi",
+    )
+  end
+
+  let(:notice_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "notice", code: "N-001", message: "note",
+    )
+  end
+
+  let(:container) do
+    all_issues = [error_issue, warning_issue, info_issue, notice_issue]
+    klass = Class.new do
+      include Lutaml::Model::Validation::HasIssues
+
+      attr_reader :issues
+
+      def initialize(issues)
+        @issues = issues
+      end
+    end
+    klass.new(all_issues)
+  end
+
+  it "filters errors" do
+    expect(container.errors).to eq([error_issue])
+  end
+
+  it "filters warnings" do
+    expect(container.warnings).to eq([warning_issue])
+  end
+
+  it "filters infos" do
+    expect(container.infos).to eq([info_issue])
+  end
+
+  it "filters notices" do
+    expect(container.notices).to eq([notice_issue])
+  end
+
+  it "returns empty arrays when no matching severity" do
+    only_errors = Class.new do
+      include Lutaml::Model::Validation::HasIssues
+
+      def issues
+        [Lutaml::Model::Validation::Issue.new(
+          severity: "error", code: "X", message: "y",
+        )]
+      end
+    end.new
+
+    expect(only_errors.warnings).to be_empty
+    expect(only_errors.infos).to be_empty
+    expect(only_errors.notices).to be_empty
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Context do
+  subject(:context) { described_class.new }
+
+  it "starts with empty errors" do
+    expect(context.errors).to be_empty
+  end
+
+  describe "#add_error" do
+    it "accumulates errors" do
+      issue = Lutaml::Model::Validation::Issue.new(
+        severity: "error", code: "T-001", message: "bad",
+      )
+      context.add_error(issue)
+      expect(context.errors.length).to eq(1)
+      expect(context.errors.first).to eq(issue)
+    end
+  end
+
+  describe "#add_errors" do
+    it "concatenates multiple errors" do
+      issues = Array.new(2) do |i|
+        Lutaml::Model::Validation::Issue.new(
+          severity: "error", code: "T-#{i}", message: "bad #{i}",
+        )
+      end
+      context.add_errors(issues)
+      expect(context.errors.length).to eq(2)
+    end
+  end
+
+  describe "#rule_state" do
+    it "provides per-rule state hash" do
+      state = context.rule_state("R-001")
+      state[:count] = 5
+      expect(context.rule_state("R-001")[:count]).to eq(5)
+    end
+
+    it "isolates state between rules" do
+      context.rule_state("R-001")[:val] = "a"
+      context.rule_state("R-002")[:val] = "b"
+      expect(context.rule_state("R-001")[:val]).to eq("a")
+      expect(context.rule_state("R-002")[:val]).to eq("b")
+    end
+  end
+
+  describe "#reset!" do
+    it "clears errors and state" do
+      context.add_error(double("issue"))
+      context.rule_state("R")[:x] = 1
+      context.reset!
+      expect(context.errors).to be_empty
+      expect(context.rule_state("R")).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Issue do
+  subject(:issue) do
+    described_class.new(
+      severity: "error",
+      code: "TEST-001",
+      message: "Something is wrong",
+      location: "file.xml",
+      line: 42,
+      suggestion: "Fix it",
+    )
+  end
+
+  describe "SEVERITIES constant" do
+    it "defines allowed severity levels" do
+      expect(described_class::SEVERITIES).to eq(%w[error warning info notice])
+    end
+  end
+
+  describe "severity validation" do
+    it "accepts valid severities" do
+      described_class::SEVERITIES.each do |sev|
+        expect { described_class.new(severity: sev, code: "T", message: "m") }
+          .not_to raise_error
+      end
+    end
+
+    it "rejects invalid severity" do
+      expect do
+        described_class.new(severity: "critical", code: "T", message: "m")
+      end.to raise_error(ArgumentError, /Invalid severity: critical/)
+    end
+
+    it "allows nil severity" do
+      expect { described_class.new(severity: nil, code: "T", message: "m") }
+        .not_to raise_error
+    end
+  end
+
+  describe "serialization" do
+    it "serializes to JSON" do
+      parsed = JSON.parse(issue.to_json)
+      expect(parsed["severity"]).to eq("error")
+      expect(parsed["code"]).to eq("TEST-001")
+      expect(parsed["message"]).to eq("Something is wrong")
+      expect(parsed["location"]).to eq("file.xml")
+      expect(parsed["line"]).to eq(42)
+      expect(parsed["suggestion"]).to eq("Fix it")
+    end
+
+    it "round-trips through JSON" do
+      restored = described_class.from_json(issue.to_json)
+      expect(restored.code).to eq("TEST-001")
+      expect(restored.message).to eq("Something is wrong")
+    end
+  end
+
+  describe "severity predicates" do
+    it "returns correct predicate for error" do
+      expect(issue).to be_error
+      expect(issue).not_to be_warning
+      expect(issue).not_to be_info
+      expect(issue).not_to be_notice
+    end
+
+    it "returns correct predicate for warning" do
+      warning = described_class.new(severity: "warning", code: "W",
+                                    message: "m")
+      expect(warning).to be_warning
+      expect(warning).not_to be_error
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::LayerResult do
+  subject(:layer) do
+    described_class.new(
+      name: "Structure",
+      status: "fail",
+      duration_ms: 15,
+      issues: [error_issue, warning_issue],
+    )
+  end
+
+  let(:error_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "error", code: "E-001", message: "bad",
+    )
+  end
+
+  let(:warning_issue) do
+    Lutaml::Model::Validation::Issue.new(
+      severity: "warning", code: "W-001", message: "meh",
+    )
+  end
+
+  it "serializes to JSON" do
+    parsed = JSON.parse(layer.to_json)
+    expect(parsed["name"]).to eq("Structure")
+    expect(parsed["status"]).to eq("fail")
+    expect(parsed["issues"].length).to eq(2)
+  end
+
+  describe "#pass? / #fail?" do
+    it "checks status" do
+      expect(layer).not_to be_pass
+      expect(layer).to be_fail
+    end
+
+    it "returns true for pass status" do
+      passing = described_class.new(name: "x", status: "pass")
+      expect(passing).to be_pass
+    end
+  end
+
+  describe "severity filtering via HasIssues" do
+    it "filters errors" do
+      expect(layer.errors.length).to eq(1)
+      expect(layer.errors.first.code).to eq("E-001")
+    end
+
+    it "filters warnings" do
+      expect(layer.warnings.length).to eq(1)
+      expect(layer.warnings.first.code).to eq("W-001")
+    end
+
+    it "returns empty for infos" do
+      expect(layer.infos).to be_empty
+    end
+
+    it "returns empty for notices" do
+      expect(layer.notices).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+require "tmpdir"
+require "yaml"
+
+RSpec.describe Lutaml::Model::Validation::Profile do
+  let(:registry) { Lutaml::Model::Validation.new_registry }
+
+  let(:profile) do
+    described_class.new(
+      name: "basic",
+      description: "Basic checks",
+      rule_names: ["TestRule"],
+    )
+  end
+
+  it "stores profile attributes" do
+    expect(profile.name).to eq("basic")
+    expect(profile.description).to eq("Basic checks")
+    expect(profile.rule_names).to eq(["TestRule"])
+    expect(profile.imports).to eq([])
+  end
+
+  describe ".load" do
+    it "loads profile from YAML file" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "basic.yml")
+        File.write(yaml_path, YAML.dump({
+                                          "name" => "loaded",
+                                          "description" => "Loaded profile",
+                                          "rules" => ["RuleA", "RuleB"],
+                                          "import" => ["base"],
+                                        }))
+        loaded = described_class.load(yaml_path)
+        expect(loaded.name).to eq("loaded")
+        expect(loaded.rule_names).to eq(["RuleA", "RuleB"])
+        expect(loaded.imports).to eq(["base"])
+      end
+    end
+
+    it "rejects YAML without a name key" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "bad.yml")
+        File.write(yaml_path, YAML.dump({ "description" => "no name" }))
+        expect { described_class.load(yaml_path) }
+          .to raise_error(ArgumentError, /must contain a 'name' string key/)
+      end
+    end
+
+    it "rejects non-hash YAML content" do
+      Dir.mktmpdir do |dir|
+        yaml_path = File.join(dir, "array.yml")
+        File.write(yaml_path, YAML.dump(["just", "an", "array"]))
+        expect { described_class.load(yaml_path) }
+          .to raise_error(ArgumentError, /must contain a 'name' string key/)
+      end
+    end
+  end
+
+  describe "#resolve" do
+    context "with imports" do
+      let(:base_rule_class) do
+        Class.new(Lutaml::Model::Validation::Rule) do
+          def self.name = "BaseRule"
+          def code = "BASE-001"
+        end
+      end
+
+      let(:extra_rule_class) do
+        Class.new(Lutaml::Model::Validation::Rule) do
+          def self.name = "ExtraRule"
+          def code = "EXTRA-001"
+        end
+      end
+
+      let(:base_profile) do
+        described_class.new(name: "base", rule_names: ["BaseRule"])
+      end
+
+      let(:extended_profile) do
+        described_class.new(
+          name: "extended",
+          rule_names: ["ExtraRule"],
+          imports: ["base"],
+        )
+      end
+
+      it "resolves imports" do
+        registry.register(base_rule_class)
+        registry.register(extra_rule_class)
+        profiles = { "base" => base_profile, "extended" => extended_profile }
+
+        rules = extended_profile.resolve(registry, profiles)
+        codes = rules.map(&:code)
+        expect(codes).to include("BASE-001", "EXTRA-001")
+      end
+
+      it "ignores missing imports" do
+        registry.register(extra_rule_class)
+        orphan = described_class.new(
+          name: "orphan",
+          rule_names: ["ExtraRule"],
+          imports: ["nonexistent"],
+        )
+        rules = orphan.resolve(registry, {})
+        expect(rules.map(&:code)).to eq(["EXTRA-001"])
+      end
+
+      it "detects circular imports" do
+        a = described_class.new(name: "a", imports: ["b"])
+        b = described_class.new(name: "b", imports: ["a"])
+        profiles = { "a" => a, "b" => b }
+        expect { a.resolve(registry, profiles) }
+          .to raise_error(ArgumentError, /Circular profile import detected: a/)
+      end
+
+      it "detects deep circular imports" do
+        a = described_class.new(name: "a", imports: ["b"])
+        b = described_class.new(name: "b", imports: ["c"])
+        c = described_class.new(name: "c", imports: ["a"])
+        profiles = { "a" => a, "b" => b, "c" => c }
+        expect { a.resolve(registry, profiles) }
+          .to raise_error(ArgumentError, /Circular profile import detected/)
+      end
+    end
+
+    it "skips rules with unknown class names" do
+      result = profile.resolve(registry)
+      expect(result).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::Registry do
+  subject(:registry) { described_class.new }
+
+  let(:rule_class) do
+    Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "REG-001"
+      def category = :test
+    end
+  end
+
+  before { registry.register(rule_class) }
+
+  it "registers and returns rule instances" do
+    rules = registry.all
+    expect(rules.length).to eq(1)
+    expect(rules.first).to be_a(rule_class)
+    expect(rules.first.code).to eq("REG-001")
+  end
+
+  it "caches rule instances" do
+    first_call = registry.all
+    second_call = registry.all
+    expect(first_call).to equal(second_call)
+  end
+
+  it "invalidates cache on new registration" do
+    first = registry.all
+    new_rule = Class.new(Lutaml::Model::Validation::Rule) do
+      def code = "REG-002"
+    end
+    registry.register(new_rule)
+    expect(registry.all).not_to equal(first)
+    expect(registry.all.length).to eq(2)
+  end
+
+  it "prevents duplicate registration" do
+    registry.register(rule_class)
+    expect(registry.size).to eq(1)
+  end
+
+  it "filters by category" do
+    rules = registry.for_category(:test)
+    expect(rules.length).to eq(1)
+    expect(registry.for_category(:other)).to be_empty
+  end
+
+  it "finds by code" do
+    rule = registry.find("REG-001")
+    expect(rule).not_to be_nil
+    expect(rule.code).to eq("REG-001")
+  end
+
+  it "returns nil for unknown code" do
+    expect(registry.find("UNKNOWN")).to be_nil
+  end
+
+  it "resets" do
+    registry.reset!
+    expect(registry.size).to eq(0)
+    expect(registry.all).to be_empty
+  end
+
+  it "returns rule classes" do
+    expect(registry.rule_classes).to eq([rule_class])
+  end
+
+  it "returns a defensive copy of rule_classes" do
+    classes = registry.rule_classes
+    classes << String
+    expect(registry.rule_classes.length).to eq(1)
+  end
+
+  describe "#auto_discover" do
+    it "requires rule files from a directory" do
+      Dir.mktmpdir do |dir|
+        rule_file = File.join(dir, "discovered_rule.rb")
+        File.write(rule_file, <<~RUBY)
+          class DiscoveredTestRule < Lutaml::Model::Validation::Rule
+            def code = "DISC-001"
+          end
+        RUBY
+
+        registry.auto_discover(dir, pattern: "*_rule.rb")
+        registry.register(DiscoveredTestRule)
+        expect(registry.find("DISC-001")).not_to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/validation_framework"
+
+RSpec.describe Lutaml::Model::Validation::RemediationResult do
+  it "serializes to JSON" do
+    result = described_class.new(
+      success: true,
+      message: "Fixed",
+      fixed_codes: ["DOC-020", "DOC-030"],
+    )
+    parsed = JSON.parse(result.to_json)
+    expect(parsed["success"]).to be true
+    expect(parsed["message"]).to eq("Fixed")
+    expect(parsed["fixed_codes"]).to eq(["DOC-020", "DOC-030"])
+  end
+
+  it "defaults fixed_codes to nil when not provided" do
+    result = described_class.new(success: false, message: "nope")
+    expect(result.fixed_codes).to be_nil
+  end
+end

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