moxml 0.1.24 → 0.1.26

data/spec/fixtures/xmldsig/sign2-result.xml

@@ -0,0 +1,25 @@
+<?xml version="1.0"?>
+<Envelope xmlns="urn:envelope">
+  <Data>
+  Hello, World!
+  </Data>
+<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
+<SignedInfo>
+<CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
+<SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/>
+<Reference>
+<Transforms>
+<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
+<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
+</Transforms>
+<DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
+<DigestValue>Gx8CGUsbi2qvBLd15VCmwELbDMND8F4vY3jPOc7/FJ0=</DigestValue>
+</Reference>
+</SignedInfo>
+<SignatureValue>T2c7nqOw55P8hcP1qhvfPCwOSEAuo8HstZf9shlrggcarxfgWTKhA6UdrF4McfrS
+XtcgHA7zy0Yzd2cgeGkKA2jgI+9QRhoQsifOMuI55sE5r+fpBs+goaxC57gmcBXj
+XnuwIiWf7nfpF4hYZ841HzYd2HcpQKPTdbhvZUprvx8=</SignatureValue>
+<KeyInfo>
+<KeyName>test</KeyName>
+</KeyInfo>
+</Signature></Envelope>

data/spec/fixtures/xmldsig/sign3-result.xml

@@ -0,0 +1,39 @@
+<?xml version="1.0"?>
+<Envelope xmlns="urn:envelope">
+  <Data>
+  Hello, World!
+  </Data>
+<Signature xmlns="http://www.w3.org/2000/09/xmldsig#">
+<SignedInfo>
+<CanonicalizationMethod Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
+<SignatureMethod Algorithm="http://www.w3.org/2001/04/xmldsig-more#rsa-sha256"/>
+<Reference>
+<Transforms>
+<Transform Algorithm="http://www.w3.org/2000/09/xmldsig#enveloped-signature"/>
+<Transform Algorithm="http://www.w3.org/2001/10/xml-exc-c14n#"/>
+</Transforms>
+<DigestMethod Algorithm="http://www.w3.org/2001/04/xmlenc#sha256"/>
+<DigestValue>Gx8CGUsbi2qvBLd15VCmwELbDMND8F4vY3jPOc7/FJ0=</DigestValue>
+</Reference>
+</SignedInfo>
+<SignatureValue>TGJ9fCzjppp3LgG4fiBJx+0R34wRa7il9XKKZ+kkOAdKkcW0PIAYKmjn0Tn8krGd
+Gw6qtFFqjdohXfhkKmajXAFunEtd3J0kHFkf3obIwRB1qdsYmKXVFxUx3GqcIlph
+vt9v/9FC12JAxwAiJXHuY2xN5uo3xSDER4+tCCy3/AI=</SignatureValue>
+<KeyInfo>
+<X509Data>
+<X509Certificate>MIICLzCCAZgCCQCVuhhQ38rw0TANBgkqhkiG9w0BAQUFADBbMQswCQYDVQQGEwJV
+UzEQMA4GA1UECAwHR2VvcmdpYTEhMB8GA1UECgwYSW50ZXJuZXQgV2lkZ2l0cyBQ
+dHkgTHRkMRcwFQYDVQQDDA53d3cuZ29vZ2xlLmNvbTAgFw0xMzA1MjUxODQwMDRa
+GA8zMDEyMDkyNTE4NDAwNFowWzELMAkGA1UEBhMCVVMxEDAOBgNVBAgMB0dlb3Jn
+aWExITAfBgNVBAoMGEludGVybmV0IFdpZGdpdHMgUHR5IEx0ZDEXMBUGA1UEAwwO
+d3d3Lmdvb2dsZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBALE4oSql
+eymfHtzOeY86WyvfsjZmaz2XnIo9dzZsK71yMEKkgvXQnnYy9pK0NaYcG0B0hcii
+3fqGBiHMkZY2BOGWwCC/wOmJCzLq9q6caPWUs71Zko+h59LaqV93vzDmZaXYfFoQ
+gSVEWpEpCSo560x0mSuLnJYdQQzZ/L6xvxZ1AgMBAAEwDQYJKoZIhvcNAQEFBQAD
+gYEATyK/RlfpohUVimgFkycTF2hyusjctseXoZDCctgg/STMsL8iA0P9YB6k91GC
+kWpwevuiwarD1MfSUV6goPINFkIBvfK+5R9lpHaTqqs615z8T9R5VJgaLcFe3tWd
+7oq3V2q5Nl6MrZfXj2N07qe6/9zfdauxYO26vAEKCvIkbMo=
+</X509Certificate>
+</X509Data>
+</KeyInfo>
+</Signature></Envelope>

data/spec/moxml/adapter/platform_spec.rb

@@ -2,69 +2,87 @@
 
 require "spec_helper"
 
-RSpec.describe Moxml::Adapter, ".platform_adapters" do
-  it "includes all known adapters under MRI" do
-    expect(described_class.platform_adapters).to include(:nokogiri, :oga,
-                                                         :rexml, :ox)
-  end
-
-  it "uses the AVAILABLE_ADAPTERS constant under MRI" do
-    expect(described_class.platform_adapters).to eq(Moxml::Adapter::AVAILABLE_ADAPTERS)
-  end
-end
-
-RSpec.describe Moxml::Adapter, ".available?" do
-  it "returns true for :oga" do
-    expect(described_class.available?(:oga)).to be true
-  end
+RSpec.describe Moxml::Adapter do
+  describe ".platform_adapters" do
+    it "includes all known adapters under MRI" do
+      expect(described_class.platform_adapters).to include(:nokogiri, :oga,
+                                                           :rexml, :ox)
+    end
 
-  it "returns true for :nokogiri under MRI" do
-    expect(described_class.available?(:nokogiri)).to be true
+    it "uses the AVAILABLE_ADAPTERS constant under MRI" do
+      expect(described_class.platform_adapters).to eq(Moxml::Adapter::AVAILABLE_ADAPTERS)
+    end
   end
 
-  context "when Opal platform adapters are in effect" do
-    before do
-      allow(described_class).to receive(:platform_adapters)
-        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+  describe ".available?" do
+    it "returns true for :oga" do
+      expect(described_class.available?(:oga)).to be true
     end
 
-    it "returns false for :nokogiri" do
-      expect(described_class.available?(:nokogiri)).to be false
+    it "returns true for :nokogiri under MRI" do
+      expect(described_class.available?(:nokogiri)).to be true
     end
 
-    it "returns true for :rexml" do
-      expect(described_class.available?(:rexml)).to be true
+    context "when Opal platform adapters are in effect" do
+      before do
+        allow(described_class).to receive(:platform_adapters)
+          .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+      end
+
+      it "returns false for :nokogiri" do
+        expect(described_class.available?(:nokogiri)).to be false
+      end
+
+      it "returns true for :oga" do
+        expect(described_class.available?(:oga)).to be true
+      end
+
+      it "returns true for :rexml" do
+        expect(described_class.available?(:rexml)).to be true
+      end
     end
   end
-end
 
-RSpec.describe Moxml::Adapter, ".load" do
-  context "when Opal platform adapters are in effect" do
-    before do
-      allow(described_class).to receive(:platform_adapters)
-        .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
-    end
+  describe ".load" do
+    context "when Opal platform adapters are in effect" do
+      before do
+        allow(described_class).to receive(:platform_adapters)
+          .and_return(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+      end
 
-    it "raises AdapterError for :nokogiri" do
-      expect { described_class.load(:nokogiri) }.to raise_error(
-        Moxml::AdapterError, /not available on this platform/
-      )
+      it "raises AdapterError for :nokogiri" do
+        expect { described_class.load(:nokogiri) }.to raise_error(
+          Moxml::AdapterError, /not available on this platform/
+        )
+      end
     end
   end
-end
 
-RSpec.describe "Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS" do
-  it "contains only :rexml" do
-    expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS).to eq(%i[rexml])
+  describe "OPAL_AVAILABLE_ADAPTERS" do
+    it "lists :oga as the primary Opal adapter, with :rexml as opt-in" do
+      expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS).to eq(%i[oga rexml])
+    end
   end
-end
 
-RSpec.describe "Moxml::Adapter::CONST_NAME_MAP" do
-  it "maps :headed_ox to HeadedOx" do
-    expect(Moxml::Adapter::CONST_NAME_MAP[:headed_ox]).to eq("HeadedOx")
+  describe "CONST_NAME_MAP" do
+    it "maps :headed_ox to HeadedOx" do
+      expect(Moxml::Adapter::CONST_NAME_MAP[:headed_ox]).to eq("HeadedOx")
+    end
+
+    it "falls back to capitalize for unmapped adapters" do
+      expect(Moxml::Adapter::CONST_NAME_MAP[:nokogiri]).to be_nil
+    end
   end
 
-  it "falls back to capitalize for unmapped adapters" do
-    expect(Moxml::Adapter::CONST_NAME_MAP[:nokogiri]).to be_nil
+  describe "default adapter / available list invariants" do
+    it "DEFAULT_ADAPTER is a member of AVAILABLE_ADAPTERS" do
+      expect(Moxml::Adapter::AVAILABLE_ADAPTERS)
+        .to include(Moxml::Config::DEFAULT_ADAPTER)
+    end
+
+    it "OPAL_DEFAULT_ADAPTER is a member of OPAL_AVAILABLE_ADAPTERS" do
+      expect(Moxml::Adapter::OPAL_AVAILABLE_ADAPTERS)
+        .to include(Moxml::Config::OPAL_DEFAULT_ADAPTER)
+    end
   end
 end

data/spec/moxml/c14n/api_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+RSpec.describe "Moxml::C14n API" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe ".canonicalize (algorithm selector)" do
+    it "defaults to inclusive C14N 1.0" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'><foo:a/></root>")
+      default_result = Moxml::C14n.canonicalize(doc.root)
+      incl10_result = Moxml::C14n.canonicalize(doc.root, algorithm: :inclusive10)
+      expect(default_result).to eq(incl10_result)
+    end
+
+    it "raises ArgumentError for unknown algorithm" do
+      expect do
+        Moxml::C14n.canonicalize("<x/>", algorithm: :bogus)
+      end.to raise_error(ArgumentError, /unknown C14N algorithm/)
+    end
+
+    it "accepts inclusive_11 algorithm" do
+      doc = ctx.parse("<root/>")
+      result = Moxml::C14n.canonicalize(doc.root, algorithm: :inclusive11)
+      expect(result).to eq("<root></root>")
+    end
+
+    it "accepts exclusive_10 algorithm" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'><foo:a/></root>")
+      result = Moxml::C14n.canonicalize(doc.root, algorithm: :exclusive10)
+      # Exclusive renders ns where visibly used (on foo:a), not on root
+      expect(result).to include('<foo:a xmlns:foo="urn:foo">')
+    end
+  end
+
+  describe ".equivalent?" do
+    it "returns true for byte-identical inputs" do
+      expect(Moxml::C14n).to be_equivalent("<root>x</root>", "<root>x</root>")
+    end
+
+    it "returns true when only attribute whitespace differs" do
+      # Whitespace inside the tag is not significant — both parse identically.
+      a = %(<root attr="value"/>)
+      b = %(<root  attr="value" />)
+      expect(Moxml::C14n).to be_equivalent(a, b)
+    end
+
+    it "returns false when text whitespace differs (text IS significant)" do
+      a = "<root><child>a</child> </root>"
+      b = "<root> <child>a</child></root>"
+      expect(Moxml::C14n).not_to be_equivalent(a, b)
+    end
+
+    it "returns true when only attribute order differs" do
+      a = %(<root a="1" b="2"/>)
+      b = %(<root b="2" a="1"/>)
+      expect(Moxml::C14n).to be_equivalent(a, b)
+    end
+
+    it "returns true when only namespace prefix differs" do
+      a = "<root xmlns:foo='urn:foo'><foo:a/></root>"
+      b = "<root xmlns:bar='urn:foo'><bar:a/></root>"
+      # Inclusive canonical form: prefix is part of qname → not equivalent
+      expect(Moxml::C14n).not_to be_equivalent(a, b)
+    end
+
+    it "returns false for different content" do
+      expect(Moxml::C14n).not_to be_equivalent("<root>a</root>", "<root>b</root>")
+    end
+
+    it "respects algorithm argument" do
+      a = "<root xmlns:foo='urn:foo'><foo:a/></root>"
+      b = "<root><a xmlns:foo='urn:foo'/></root>"
+      # Inclusive: ns on root vs on child → different
+      expect(Moxml::C14n).not_to be_equivalent(a, b, algorithm: :inclusive10)
+    end
+
+    it "accepts Moxml::Node inputs" do
+      doc1 = ctx.parse("<root/>")
+      doc2 = ctx.parse("<root></root>")
+      expect(Moxml::C14n).to be_equivalent(doc1.root, doc2.root)
+    end
+  end
+
+  describe "convenience methods" do
+    it ".canonicalize_inclusive10 matches default" do
+      doc = ctx.parse("<root/>")
+      expect(Moxml::C14n.canonicalize_inclusive10(doc.root))
+        .to eq(Moxml::C14n.canonicalize(doc.root))
+    end
+
+    it ".canonicalize_inclusive11 produces output" do
+      doc = ctx.parse("<root/>")
+      expect(Moxml::C14n.canonicalize_inclusive11(doc.root)).to eq("<root></root>")
+    end
+
+    it ".canonicalize_exclusive accepts inclusive_namespaces" do
+      doc = ctx.parse("<root xmlns:foo='urn:foo'/>")
+      result = Moxml::C14n.canonicalize_exclusive(doc.root, inclusive_namespaces: ["foo"])
+      # Even though foo is not visibly used, inclusive list forces render
+      expect(result).to include('xmlns:foo="urn:foo"')
+    end
+  end
+
+  describe "escape helpers (backward compat)" do
+    it ".escape_text escapes & < >" do
+      expect(Moxml::C14n.escape_text("a & b < c > d"))
+        .to eq("a &amp; b &lt; c &gt; d")
+    end
+
+    it ".escape_attribute escapes quotes and whitespace" do
+      expect(Moxml::C14n.escape_attribute(%(a"b\tc\nd)))
+        .to eq(%(a&quot;b&#x9;c&#xA;d))
+    end
+  end
+end

data/spec/moxml/c14n/c14n_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe "Moxml C14N engine" do
+  describe Moxml::C14n::Exclusive do
+    let(:ctx) { Moxml.new(:nokogiri) }
+    let(:canon) { described_class.new }
+
+    it "renders a simple element without namespaces" do
+      doc = ctx.parse("<root>hello</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>hello</root>")
+    end
+
+    it "preserves nested element structure" do
+      doc = ctx.parse("<root><child>text</child></root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root><child>text</child></root>")
+    end
+
+    it "renders declared namespaces" do
+      doc = ctx.parse(<<~XML.strip)
+        <root xmlns:foo="http://example.com/foo"><foo:child>x</foo:child></root>
+      XML
+      result = canon.canonicalize(doc.root)
+      # Exclusive C14N renders the namespace on the element where it's visibly
+      # used (foo:child), not on ancestors that don't use it.
+      expect(result).to include('<foo:child xmlns:foo="http://example.com/foo">')
+      expect(result).to include("</foo:child>")
+    end
+
+    it "excludes ancestor-inherited namespaces when not visibly used (exclusive)" do
+      doc = ctx.parse(<<~XML.strip)
+        <outer xmlns:unused="http://example.com/unused"><inner>text</inner></outer>
+      XML
+      inner = doc.at_xpath("//inner")
+      result = canon.canonicalize(inner)
+      expect(result).to eq("<inner>text</inner>")
+    end
+
+    it "escapes special characters in text content" do
+      doc = ctx.parse("<root>a&lt;b&gt;c&amp;d</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>a&lt;b&gt;c&amp;d</root>")
+    end
+
+    it "escapes special characters in attribute values" do
+      doc = ctx.parse(%(<root attr="a&amp;b&quot;c"/>))
+      expect(canon.canonicalize(doc.root))
+        .to include(%(attr="a&amp;b&quot;c"))
+    end
+
+    it "sorts attributes by namespace URI then local name" do
+      doc = ctx.parse(%(<root b="2" a="1" c="3"/>))
+      result = canon.canonicalize(doc.root)
+      expect(result).to include('a="1" b="2" c="3"')
+    end
+
+    it "omits comments by default" do
+      doc = ctx.parse("<root>a<!-- comment -->b</root>")
+      expect(canon.canonicalize(doc.root)).to eq("<root>ab</root>")
+    end
+
+    it "includes comments when with_comments is true" do
+      doc = ctx.parse("<root>a<!-- comment -->b</root>")
+      expect(canon.canonicalize(doc.root, with_comments: true))
+        .to eq("<root>a<!-- comment -->b</root>")
+    end
+  end
+
+  describe ".escape_text" do
+    it "escapes &, <, >" do
+      expect(Moxml::C14n.escape_text("a & b < c > d"))
+        .to eq("a &amp; b &lt; c &gt; d")
+    end
+
+    it "escapes bare CR as &#xD;" do
+      expect(Moxml::C14n.escape_text("a\rb"))
+        .to eq("a&#xD;b")
+    end
+  end
+
+  describe ".escape_attribute" do
+    it "escapes quotes and tabs/newlines" do
+      expect(Moxml::C14n.escape_attribute(%(a"b\tc\nd)))
+        .to eq(%(a&quot;b&#x9;c&#xA;d))
+    end
+  end
+end

data/spec/moxml/c14n/comments_pis_spec.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Edge cases for comment and processing-instruction handling per
+# W3C C14N 1.0 §2.6, §2.7.
+RSpec.describe "C14N comments and PIs" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe "comments inside elements" do
+    it "omits comments by default" do
+      doc = ctx.parse("<root>a<!-- c -->b</root>")
+      expect(Moxml::C14n.canonicalize(doc.root)).to eq("<root>ab</root>")
+    end
+
+    it "includes comments when with_comments: true" do
+      doc = ctx.parse("<root>a<!-- c -->b</root>")
+      expect(Moxml::C14n.canonicalize(doc.root, with_comments: true))
+        .to eq("<root>a<!-- c -->b</root>")
+    end
+
+    it "preserves comment content verbatim" do
+      doc = ctx.parse("<root><!-- &amp; <stuff> --></root>")
+      expect(Moxml::C14n.canonicalize(doc.root, with_comments: true))
+        .to eq("<root><!-- &amp; <stuff> --></root>")
+    end
+  end
+
+  describe "processing instructions" do
+    it "always renders PIs (not affected by with_comments)" do
+      doc = ctx.parse("<root><?pi data?>x</root>")
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to eq("<root><?pi data?>x</root>")
+    end
+
+    it "renders PI without data when data is empty" do
+      doc = ctx.parse("<root><?pi?>x</root>")
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to eq("<root><?pi?>x</root>")
+    end
+
+    it "preserves PI target and data verbatim" do
+      doc = ctx.parse(%(<root><?xml-stylesheet href="a.css" type="text/css"?>x</root>))
+      expect(Moxml::C14n.canonicalize(doc.root))
+        .to include(%(<?xml-stylesheet href="a.css" type="text/css"?>))
+    end
+  end
+
+  describe "PIs at document level" do
+    # TODO.c14n/09: Document-level PIs (outside the document element) are
+    # not yet rendered correctly. The moxml PI parser mis-parses document-level
+    # PIs, and the DataModel.from_document path drops them. Fixing requires
+    # adapter-level work and is tracked separately.
+    it "renders PIs outside the document element (KNOWN LIMITATION)" do
+      skip "document-level PI rendering not yet implemented"
+    end
+  end
+
+  describe "comments at document level" do
+    it "renders document-level comments when with_comments: true (KNOWN LIMITATION)" do
+      skip "document-level comment rendering not yet implemented"
+    end
+  end
+end

data/spec/moxml/c14n/inclusive10_spec.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe Moxml::C14n::Inclusive10 do
+  let(:ctx) { Moxml.new(:nokogiri) }
+  let(:canon) { described_class.new }
+
+  it "renders a simple element" do
+    doc = ctx.parse("<root>hello</root>")
+    expect(canon.canonicalize(doc.root)).to eq("<root>hello</root>")
+  end
+
+  it "attracts ancestor namespaces at the apex (the key inclusive behavior)" do
+    xml = <<~XML.strip
+      <outer xmlns:foo="http://example.com/foo" xmlns:bar="http://example.com/bar">
+        <inner x="1"><foo:child>hello</foo:child></inner>
+      </outer>
+    XML
+    doc = ctx.parse(xml)
+    inner = doc.at_xpath("//*[local-name()='inner']")
+    result = canon.canonicalize(inner)
+    # Both inherited namespaces are rendered on <inner>, even though
+    # <inner> itself does not visibly use them. This is the inclusive
+    # "ancestor attraction" behavior.
+    expect(result).to include('xmlns:bar="http://example.com/bar"')
+    expect(result).to include('xmlns:foo="http://example.com/foo"')
+  end
+
+  it "renders each namespace declaration only once per chain" do
+    xml = <<~XML.strip
+      <root xmlns:a="http://example.com/a">
+        <child xmlns:a="http://example.com/a"><grand/></child>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    result = canon.canonicalize(doc.root)
+    expect(result.scan('xmlns:a="http://example.com/a"').count).to eq(1)
+  end
+
+  it "re-renders a namespace when re-declared with a different URI" do
+    xml = <<~XML.strip
+      <root xmlns:a="http://example.com/a">
+        <child xmlns:a="http://example.com/other"><grand/></child>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    result = canon.canonicalize(doc.root)
+    expect(result.scan("xmlns:a=").count).to eq(2)
+  end
+
+  it "renders the default namespace at apex when inherited" do
+    xml = '<outer xmlns="http://example.com"><inner/></outer>'
+    doc = ctx.parse(xml)
+    inner = doc.at_xpath("//*[local-name()='inner']")
+    result = canon.canonicalize(inner)
+    expect(result).to include('xmlns="http://example.com"')
+  end
+end

data/spec/moxml/c14n/namespace_edge_cases_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# Edge cases for namespace rendering per W3C C14N 1.0 §2.3 / 1.1 §2.3.
+# These cover the bugs that historically plague C14N implementations.
+RSpec.describe "C14N namespace rendering" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  describe "default namespace" do
+    it "renders xmlns= declaration when default ns is set" do
+      doc = ctx.parse(%(<root xmlns="urn:foo"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).to eq('<root xmlns="urn:foo"></root>')
+    end
+
+    it "renders xmlns='' when transitioning to empty default" do
+      doc = ctx.parse(%(<a xmlns="urn:foo"><b xmlns=""><c/></b></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # <b> has empty default; <a> has urn:foo → xmlns="" appears
+      expect(result).to include('xmlns=""')
+    end
+
+    it "does not render xmlns when default ns is empty everywhere" do
+      doc = ctx.parse(%(<root><child/></root>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).to eq("<root><child></child></root>")
+    end
+  end
+
+  describe "prefix redeclaration" do
+    it "renders both declarations when URI changes" do
+      doc = ctx.parse(%(<a xmlns:x="urn:1"><b xmlns:x="urn:2"/></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result.scan("xmlns:x=").length).to eq(2)
+    end
+
+    it "renders only once when URI is unchanged" do
+      doc = ctx.parse(%(<a xmlns:x="urn:1"><b xmlns:x="urn:1"/></a>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result.scan("xmlns:x=").length).to eq(1)
+    end
+  end
+
+  describe "xml namespace" do
+    it "does not render xmlns:xml declaration" do
+      doc = ctx.parse(%(<root xmlns:xml="http://www.w3.org/XML/1998/namespace"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      expect(result).not_to include("xmlns:xml=")
+    end
+  end
+
+  describe "namespace sorting" do
+    it "sorts xmlns declarations by prefix" do
+      doc = ctx.parse(%(<root xmlns:z="urn:z" xmlns:a="urn:a"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # a should appear before z
+      expect(result.index("xmlns:a=")).to be < result.index("xmlns:z=")
+    end
+
+    it "renders default namespace first" do
+      doc = ctx.parse(%(<root xmlns="urn:default" xmlns:a="urn:a"/>))
+      result = Moxml::C14n.canonicalize(doc.root)
+      # Default (xmlns=) before prefixed
+      expect(result.index("xmlns=")).to be < result.index("xmlns:a=")
+    end
+  end
+
+  describe "deeply nested inheritance" do
+    it "renders each prefix at the level it is first declared" do
+      xml = <<~XML.strip
+        <root xmlns:a="urn:a">
+          <level1 xmlns:b="urn:b">
+            <level2 xmlns:c="urn:c">
+              <apex/>
+            </level2>
+          </level1>
+        </root>
+      XML
+      doc = ctx.parse(xml)
+      result = Moxml::C14n.canonicalize(doc.root)
+      # Inclusive: all in-scope ns render on apex. But we're canonicalizing
+      # the whole tree, so each ns renders at its declaration point.
+      expect(result.scan("xmlns:").length).to eq(3)
+    end
+  end
+end