lutaml-model 0.8.17 → 0.8.18

data/spec/lutaml/xml/validate_xml_with_constructs_spec.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "validate_xml_with XSD constructs" do
+  def fixture_path(name)
+    File.expand_path("../../fixtures/xml/#{name}", __dir__)
+  end
+
+  describe "kitchen-sink schema (pattern, enumeration, attributes, " \
+           "types, occurrence, nested complex type)" do
+    before do
+      path = fixture_path("validate_xml_with_product.xsd")
+
+      stub_const("XsdDimensions", Class.new(Lutaml::Model::Serializable) do
+        attribute :width, :string
+        attribute :height, :string
+
+        xml do
+          element "dimensions"
+          map_element "width", to: :width
+          map_element "height", to: :height
+        end
+      end)
+
+      stub_const("XsdProduct", Class.new(Lutaml::Model::Serializable) do
+        attribute :id, :string
+        attribute :status, :string
+        attribute :sku, :string
+        attribute :price, :string
+        attribute :released, :string
+        attribute :tags, :string, collection: true
+        attribute :note, :string
+        attribute :dimensions, XsdDimensions
+
+        xml do
+          element "product"
+          map_attribute "id", to: :id
+          map_attribute "status", to: :status
+          map_element "sku", to: :sku
+          map_element "price", to: :price
+          map_element "released", to: :released
+          map_element "tag", to: :tags
+          map_element "note", to: :note
+          map_element "dimensions", to: :dimensions
+        end
+
+        validate_xml_with path
+      end)
+    end
+
+    let(:valid_attributes) do
+      {
+        id: "p1",
+        status: "published",
+        sku: "ABC-1234",
+        price: "9.99",
+        released: "2026-06-11",
+        tags: %w[a b c],
+        note: "boundary case: three tags is maxOccurs",
+        dimensions: XsdDimensions.new(width: "10", height: "20"),
+      }
+    end
+
+    def product(**overrides)
+      XsdProduct.new(valid_attributes.merge(overrides))
+    end
+
+    it "accepts a document satisfying every construct" do
+      expect(product.validate).to be_empty
+    end
+
+    it "accepts a document omitting all optional parts" do
+      minimal = product(status: nil, tags: [], note: nil, dimensions: nil)
+
+      expect(minimal.validate).to be_empty
+    end
+
+    it "collects xs:pattern violations" do
+      errors = product(sku: "bad-sku").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("sku"))
+    end
+
+    it "collects xs:enumeration violations" do
+      errors = product(status: "archived").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("status"))
+    end
+
+    it "collects missing required attribute violations" do
+      errors = product(id: nil).validate
+
+      expect(errors.map(&:message)).to include(
+        a_string_including("attribute 'id' is required"),
+      )
+    end
+
+    it "collects xs:decimal lexical violations" do
+      errors = product(price: "free").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("price"))
+    end
+
+    it "collects xs:date lexical violations" do
+      errors = product(released: "tomorrow").validate
+
+      expect(errors.map(&:message)).to include(a_string_including("released"))
+    end
+
+    it "collects maxOccurs violations" do
+      errors = product(tags: %w[a b c d]).validate
+
+      expect(errors.map(&:message)).to include(a_string_including("tag"))
+    end
+
+    it "collects violations inside nested complex types" do
+      bad_nested = XsdDimensions.new(width: "wide", height: "20")
+      errors = product(dimensions: bad_nested).validate
+
+      expect(errors.map(&:message)).to include(a_string_including("width"))
+    end
+  end
+
+  describe "multiple schema paths" do
+    before do
+      base = fixture_path("validate_xml_with_person.xsd")
+      strict = fixture_path("validate_xml_with_person_strict.xsd")
+
+      stub_const("XsdDualSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+                   attribute :age, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                     map_element "age", to: :age
+                   end
+
+                   validate_xml_with base, strict
+                 end)
+    end
+
+    it "passes when the document conforms to every schema" do
+      person = XsdDualSchemaPerson.new(name: "Alice", age: "30")
+
+      expect(person.validate).to be_empty
+    end
+
+    it "attributes violations to the schema that rejected the document" do
+      person = XsdDualSchemaPerson.new(name: "Old", age: "200")
+      errors = person.validate
+
+      expect(errors.size).to eq(1)
+      expect(errors.first.schema_path).to eq(
+        fixture_path("validate_xml_with_person_strict.xsd"),
+      )
+    end
+  end
+
+  describe "targetNamespace with qualified elements" do
+    let(:schema_path) { fixture_path("validate_xml_with_address.xsd") }
+
+    before do
+      path = schema_path
+      stub_const("XsdNamespacedDoc",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :city, :string
+
+                   xml do
+                     element "address"
+                     map_element "city", to: :city
+                   end
+
+                   validate_xml_with path
+                 end)
+    end
+
+    it "accepts a document in the target namespace" do
+      xml = '<address xmlns="http://example.com/address">' \
+            "<city>Berlin</city></address>"
+
+      expect(XsdNamespacedDoc.validate_xml(xml)).to be_empty
+    end
+
+    it "rejects a document missing the target namespace" do
+      xml = "<address><city>Berlin</city></address>"
+
+      expect(XsdNamespacedDoc.validate_xml(xml)).not_to be_empty
+    end
+  end
+
+  describe "xs:choice" do
+    before do
+      path = fixture_path("validate_xml_with_contact.xsd")
+      stub_const("XsdChoiceDoc",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :email, :string
+
+                   xml do
+                     element "contact"
+                     map_element "email", to: :email
+                   end
+
+                   validate_xml_with path
+                 end)
+    end
+
+    it "accepts a document using exactly one branch" do
+      xml = "<contact><email>a@b.c</email></contact>"
+
+      expect(XsdChoiceDoc.validate_xml(xml)).to be_empty
+    end
+
+    it "rejects a document using both branches" do
+      xml = "<contact><email>a@b.c</email><phone>123</phone></contact>"
+
+      expect(XsdChoiceDoc.validate_xml(xml)).not_to be_empty
+    end
+  end
+end

data/spec/lutaml/xml/validate_xml_with_spec.rb

@@ -0,0 +1,186 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+RSpec.describe "validate_xml_with" do
+  let(:schema_path) do
+    File.expand_path("../../fixtures/xml/validate_xml_with_person.xsd",
+                     __dir__)
+  end
+
+  before do
+    path = schema_path
+    stub_const("XsdValidatedPerson",
+               Class.new(Lutaml::Model::Serializable) do
+                 attribute :name, :string
+                 attribute :age, :string
+
+                 xml do
+                   element "person"
+                   map_element "name", to: :name
+                   map_element "age", to: :age
+                 end
+
+                 validate_xml_with path
+               end)
+  end
+
+  context "when the generated XML conforms to the schema" do
+    let(:person) { XsdValidatedPerson.new(name: "Alice", age: "30") }
+
+    it "returns no errors from validate" do
+      expect(person.validate).to be_empty
+    end
+
+    it "does not raise on validate!" do
+      expect { person.validate! }.not_to raise_error
+    end
+  end
+
+  context "when the generated XML violates the schema" do
+    let(:person) { XsdValidatedPerson.new(name: "Alice", age: "abc") }
+
+    it "collects schema validation errors" do
+      errors = person.validate
+
+      expect(errors).to all(
+        be_a(Lutaml::Xml::Error::SchemaValidationError),
+      )
+      expect(errors.first.message).to include(schema_path)
+    end
+
+    it "raises ValidationError with the schema message on validate!" do
+      expect { person.validate! }.to raise_error(
+        Lutaml::Model::ValidationError,
+        /age/,
+      )
+    end
+  end
+
+  describe ".validate_xml / .validate_xml!" do
+    let(:valid_xml) do
+      "<person><name>Alice</name><age>30</age></person>"
+    end
+    let(:invalid_xml) do
+      "<person><name>Alice</name><age>abc</age></person>"
+    end
+
+    it "returns no errors for a conforming raw XML string" do
+      expect(XsdValidatedPerson.validate_xml(valid_xml)).to be_empty
+    end
+
+    it "collects errors for a non-conforming raw XML string" do
+      errors = XsdValidatedPerson.validate_xml(invalid_xml)
+
+      expect(errors).to all(
+        be_a(Lutaml::Xml::Error::SchemaValidationError),
+      )
+    end
+
+    it "raises ValidationError for a non-conforming raw XML string" do
+      expect do
+        XsdValidatedPerson.validate_xml!(invalid_xml)
+      end.to raise_error(Lutaml::Model::ValidationError, /age/)
+    end
+
+    it "raises a parse error for malformed XML instead of recovering" do
+      expect do
+        XsdValidatedPerson.validate_xml("<person><name>Alice</name>")
+      end.to raise_error(Nokogiri::XML::SyntaxError)
+    end
+  end
+
+  context "with schema path inheritance" do
+    before do
+      stub_const("XsdValidatedEmployee", Class.new(XsdValidatedPerson))
+      stub_const("XsdAugmentedEmployee",
+                 Class.new(XsdValidatedPerson) do
+                   validate_xml_with "extra/employee.xsd"
+                 end)
+    end
+
+    it "subclasses inherit the parent's schema" do
+      employee = XsdValidatedEmployee.new(name: "Bob", age: "abc")
+
+      expect(employee.validate).not_to be_empty
+    end
+
+    it "a subclass macro call appends parent-first" do
+      expect(XsdAugmentedEmployee.xml_schema_paths).to eq(
+        [schema_path, File.expand_path("extra/employee.xsd", __dir__)],
+      )
+    end
+
+    it "does not leak child paths back to the parent" do
+      expect(XsdValidatedPerson.xml_schema_paths).to eq([schema_path])
+    end
+  end
+
+  context "with a schema path relative to the declaring file" do
+    before do
+      stub_const("RelativeSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+                   attribute :age, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                     map_element "age", to: :age
+                   end
+
+                   validate_xml_with(
+                     "../../fixtures/xml/validate_xml_with_person.xsd",
+                   )
+                 end)
+    end
+
+    it "resolves the schema next to the declaring file, not the CWD" do
+      Dir.chdir(Dir.tmpdir) do
+        person = RelativeSchemaPerson.new(name: "Alice", age: "abc")
+
+        expect(person.validate).not_to be_empty
+      end
+    end
+  end
+
+  context "when no schema is configured" do
+    before do
+      stub_const("PlainPerson", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+
+        xml do
+          element "person"
+          map_element "name", to: :name
+        end
+      end)
+    end
+
+    it "validates without touching XSD machinery" do
+      expect(PlainPerson.new(name: "Alice").validate).to be_empty
+    end
+  end
+
+  context "when the schema file does not exist" do
+    before do
+      stub_const("MissingSchemaPerson",
+                 Class.new(Lutaml::Model::Serializable) do
+                   attribute :name, :string
+
+                   xml do
+                     element "person"
+                     map_element "name", to: :name
+                   end
+
+                   validate_xml_with "nonexistent/schema.xsd"
+                 end)
+    end
+
+    it "raises a configuration-level error" do
+      expect do
+        MissingSchemaPerson.new(name: "Alice").validate
+      end.to raise_error(Errno::ENOENT)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "liquid"
+require "liquid" unless RUBY_ENGINE == "opal"
 require "rspec/matchers"
-require "canon"
+require "canon" unless RUBY_ENGINE == "opal"
 
 RSpec.configure do |config|
   # Enable flags like --only-failures and --next-failure
@@ -71,11 +71,27 @@ RSpec.configure do |config|
 
     end
   end
+
+  # Under Opal, exclude specs that require native-only adapters,
+  # filesystem, subprocess, schema compilation, or liquid templates.
+  if RUBY_ENGINE == "opal"
+    config.filter_run_excluding(
+      :native_adapter,
+      :native_fs,
+      :subprocess,
+      :performance,
+      :examples,
+      :consistency,
+      :xsd_schema,
+      :relaxng,
+      :liquid,
+    )
+  end
 end
 
 # configuration example
-require_relative "../lib/lutaml/model"
-require_relative "../lib/lutaml/xml"
+require "lutaml/model"
+require "lutaml/xml"
 require_relative "support/test_namespaces"
 require_relative "support/test_adapter_config"
 # require_relative "../lib/lutaml/xml/adapter/nokogiri_adapter"
@@ -83,16 +99,17 @@ require_relative "support/test_adapter_config"
 # require_relative "../lib/lutaml/model/toml_adapter/toml_rb_adapter"
 
 Lutaml::Model::Config.configure do |config|
-  config.xml_adapter_type = :nokogiri
+  config.xml_adapter_type  = RUBY_ENGINE == "opal" ? :oga : :nokogiri
   config.hash_adapter_type = :standard
   config.json_adapter_type = :standard
   config.yaml_adapter_type = :standard
-  config.toml_adapter_type = :toml_rb
+  # toml_rb uses native ext; not registered as a lutaml format under Opal.
+  config.toml_adapter_type = :toml_rb unless RUBY_ENGINE == "opal"
 end
 
-# Configure Canon for XML equivalence testing
-# Use spec_friendly profile which includes structural_whitespace: :ignore
-# This allows pretty-printed XML to be compared with compact XML
-Canon::Config.configure do |config|
-  config.xml.match.profile = :spec_friendly
+# Configure Canon for XML equivalence testing (Canon is not loaded under Opal)
+if defined?(Canon::Config)
+  Canon::Config.configure do |config|
+    config.xml.match.profile = :spec_friendly
+  end
 end

data/spec/support/opal.rb

@@ -1,6 +1,9 @@
 # frozen_string_literal: true
 
-# Opal runtime patches for lutaml-model specs
+# Opal runtime patches for lutaml-model specs.
+# Oga (via moxml's vendored opal-oga fork) is the default XML adapter
+# under Opal; REXML (bundled stdlib gem, pure Ruby) is also available.
+# Smoke specs parameterize over both — see spec/lutaml/xml/opal_xml_spec.rb.
 if RUBY_ENGINE == "opal"
-  Lutaml::Model::Config.xml_adapter_type = :rexml
+  Lutaml::Model::Config.xml_adapter_type = :oga
 end