moxml 0.1.24 → 0.1.26

data/spec/moxml/c14n/xml_attributes_spec.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/c14n"
+
+# xml:lang and xml:space are "simple inheritable" attributes per W3C C14N
+# 1.1 §2.4. When an element is in the node-set but an ancestor is not,
+# the canonical form inherits these attributes from the nearest ancestor
+# in which they were declared.
+#
+# These specs exercise the inclusive behavior at full-document
+# canonicalization (where everything is in the set, so inheritance
+# doesn't trigger). For subset scenarios, see TODO.c14n/07.
+RSpec.describe "C14N xml:* inheritable attributes" do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  it "renders xml:lang attribute" do
+    doc = ctx.parse(%(<root xml:lang="en">hello</root>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:lang="en">hello</root>))
+  end
+
+  it "renders xml:space attribute" do
+    doc = ctx.parse(%(<root xml:space="preserve">data</root>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:space="preserve">data</root>))
+  end
+
+  it "renders xml:lang on descendant that declares its own" do
+    doc = ctx.parse(%(<a xml:lang="en"><b xml:lang="fr"/></a>))
+    result = Moxml::C14n.canonicalize(doc.root)
+    expect(result).to include('<b xml:lang="fr">')
+  end
+
+  it "renders xml:id attribute" do
+    doc = ctx.parse(%(<root xml:id="foo"/>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:id="foo"></root>))
+  end
+
+  it "renders xml:base attribute" do
+    doc = ctx.parse(%(<root xml:base="http://example.com/"/>))
+    expect(Moxml::C14n.canonicalize(doc.root))
+      .to eq(%(<root xml:base="http://example.com/"></root>))
+  end
+
+  it "sorts xml:* attributes by namespace URI then local name" do
+    doc = ctx.parse(%(<root xml:space="default" xml:lang="en" xml:id="x"/>))
+    result = Moxml::C14n.canonicalize(doc.root)
+    # All in XML namespace; sort by local name: id < lang < space
+    expect(result.index("xml:id=")).to be < result.index("xml:lang=")
+    expect(result.index("xml:lang=")).to be < result.index("xml:space=")
+  end
+end

data/spec/moxml/opal_oga_adapter_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/adapter/shared_examples/adapter_contract"
+
+RSpec.describe Moxml::Adapter::Oga, if: RUBY_ENGINE == "opal" do
+  around do |example|
+    Moxml.with_config(:oga, true, "UTF-8") do
+      example.run
+    end
+  end
+
+  it_behaves_like "xml adapter"
+end

data/spec/moxml/opal_oga_features_spec.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Exercises feature areas under Opal that are not covered by the shared
+# adapter contract (opal_oga_adapter_spec.rb) or the basic smoke spec
+# (opal_oga_smoke_spec.rb). Targets the default Opal adapter (:oga).
+# Uses an explicit :oga context so leaked global config from other specs
+# cannot flip the adapter under test.
+RSpec.describe "Moxml Opal oga feature coverage", if: RUBY_ENGINE == "opal" do
+  let(:context) { Moxml.new(:oga) }
+
+  describe "builder DSL" do
+    it "builds a document with the block DSL" do
+      doc = Moxml::Builder.new(context).build do
+        root do
+          child "text"
+        end
+      end
+
+      expect(doc.root.name).to eq("root")
+      expect(doc.root.children.first.name).to eq("child")
+      expect(doc.root.children.first.text).to eq("text")
+    end
+
+    it "creates nested elements via blocks" do
+      doc = Moxml::Builder.new(context).build do
+        library do
+          book(id: "1") { title "A" }
+          book(id: "2") { title "B" }
+        end
+      end
+
+      books = doc.root.children.grep(Moxml::Element)
+      expect(books.length).to eq(2)
+      expect(books.map { |b| b["id"] }).to eq(%w[1 2])
+    end
+
+    it "supports method_missing DSL with attributes and text" do
+      doc = Moxml::Builder.new(context).build do
+        person(name: "Alice", age: "30") { email "alice@example.com" }
+      end
+
+      person = doc.root
+      expect(person.name).to eq("person")
+      expect(person["name"]).to eq("Alice")
+      expect(person["age"]).to eq("30")
+      expect(person.children.first.name).to eq("email")
+      expect(person.children.first.text).to eq("alice@example.com")
+    end
+
+    it "strips trailing underscore for reserved-name tags" do
+      doc = Moxml::Builder.new(context).build do
+        class_ { name "Foo" }
+      end
+
+      expect(doc.root.name).to eq("class")
+    end
+
+    it "attaches namespace declarations" do
+      builder = Moxml::Builder.new(context)
+      doc = builder.build do
+        root("xmlns:dc": "http://purl.org/dc/elements/1.1/") do
+          builder.element("dc:title") { builder.text "Hello" }
+        end
+      end
+
+      title = doc.root.children.find { |c| c.is_a?(Moxml::Element) }
+      expect(title.name).to eq("dc:title")
+      expect(doc.to_xml).to include("xmlns:dc")
+      expect(doc.to_xml).to include("dc:title")
+    end
+  end
+
+  describe "XML declaration preservation" do
+    it "does not add a declaration when the input has none" do
+      doc = context.parse("<root><child/></root>")
+      output = doc.to_xml
+
+      expect(output).not_to include("<?xml")
+      expect(doc.has_xml_declaration).to be false
+    end
+
+    it "preserves the declaration when the input has one" do
+      xml = '<?xml version="1.0" encoding="UTF-8"?><root/>'
+      doc = context.parse(xml)
+
+      expect(doc.has_xml_declaration).to be true
+      expect(doc.to_xml).to include("<?xml")
+      expect(doc.to_xml).to include('version="1.0"')
+    end
+
+    it "forces the declaration on with declaration: true" do
+      doc = context.parse("<root/>")
+      expect(doc.to_xml(declaration: true)).to include("<?xml")
+    end
+
+    it "forces the declaration off with declaration: false" do
+      doc = context.parse('<?xml version="1.0"?><root/>')
+      expect(doc.to_xml(declaration: false)).not_to include("<?xml")
+    end
+
+    it "preserves standalone attribute" do
+      xml = '<?xml version="1.0" standalone="yes"?><root/>'
+      doc = context.parse(xml)
+      expect(doc.to_xml).to include("standalone")
+    end
+  end
+
+  describe "doctype handling" do
+    it "parses a SIMPLE doctype" do
+      doc = context.parse("<!DOCTYPE root><root/>")
+      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
+      expect(doctype).not_to be_nil
+      expect(doctype.name).to eq("root")
+    end
+
+    it "parses a PUBLIC doctype with external and system ids" do
+      xml = '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"><html/>'
+      doc = context.parse(xml)
+      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
+
+      expect(doctype).not_to be_nil
+      expect(doctype.name).to eq("html")
+      expect(doctype.external_id).to eq("-//W3C//DTD HTML 4.01//EN")
+      expect(doctype.system_id).to eq("http://www.w3.org/TR/html4/strict.dtd")
+    end
+
+    it "round-trips the doctype through serialization" do
+      xml = "<!DOCTYPE root><root/>"
+      doc = context.parse(xml)
+      expect(doc.to_xml).to include("DOCTYPE")
+      expect(doc.to_xml).to include("root")
+    end
+  end
+
+  describe "round-trip stability" do
+    it "round-trips a document with mixed content" do
+      xml = <<~XML.strip
+        <root attr="value">
+          <child>text</child>
+          <!-- comment -->
+          <nested><deep>data</deep></nested>
+        </root>
+      XML
+
+      doc1 = context.parse(xml)
+      serialized1 = doc1.to_xml
+      doc2 = context.parse(serialized1)
+      serialized2 = doc2.to_xml
+
+      expect(serialized2).to eq(serialized1)
+    end
+
+    it "round-trips a document with namespaces" do
+      xml = '<root xmlns:ns="http://example.com/ns"><ns:child>content</ns:child></root>'
+      doc1 = context.parse(xml)
+      serialized1 = doc1.to_xml
+
+      doc2 = context.parse(serialized1)
+      child = doc2.root.children.find { |c| c.is_a?(Moxml::Element) }
+      expect(child.name).to eq("child")
+      expect(child.namespace_prefix).to eq("ns")
+      expect(doc2.to_xml).to include("xmlns:ns")
+    end
+
+    it "round-trips a document with CDATA" do
+      xml = "<root><![CDATA[<unparsed>content</unparsed>]]></root>"
+      doc1 = context.parse(xml)
+      serialized1 = doc1.to_xml
+
+      expect(serialized1).to include("<![CDATA[")
+      doc2 = context.parse(serialized1)
+      expect(doc2.to_xml).to include("<![CDATA[")
+    end
+  end
+
+  describe "XPath under Opal" do
+    it "evaluates element-only XPath" do
+      doc = context.parse("<root><a><b>1</b></a><a><b>2</b></a></root>")
+      results = doc.xpath("//a/b")
+      expect(results.length).to eq(2)
+      expect(results.map(&:text)).to eq(%w[1 2])
+    end
+
+    it "supports attribute predicates" do
+      doc = context.parse('<root><item id="x">1</item><item id="y">2</item></root>')
+      found = doc.xpath("//item").find { |i| i["id"] == "y" }
+      expect(found.text).to eq("2")
+    end
+
+    it "supports at_xpath" do
+      doc = context.parse("<root><a>1</a><a>2</a></root>")
+      first = doc.at_xpath("//a")
+      expect(first.text).to eq("1")
+    end
+  end
+
+  describe "comment and processing instruction handling" do
+    it "preserves comments through parse/serialize" do
+      xml = "<root><!-- my comment --></root>"
+      doc = context.parse(xml)
+      expect(doc.to_xml).to include("my comment")
+    end
+
+    it "preserves processing instructions through parse/serialize" do
+      xml = "<?pi-target pi-data?><root/>"
+      doc = context.parse(xml)
+      expect(doc.to_xml).to include("pi-target")
+    end
+  end
+end

data/spec/moxml/opal_oga_smoke_spec.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Verifies that the Opal default adapter (:oga, set in Moxml::Config)
+# loads correctly via the Opal-compatible oga fork. The fork's
+# lib/oga.rb dispatches `require 'liboga'` to `require 'oga/native/lexer'`
+# under Opal, which resolves to the pure-Ruby lexer vendored at
+# vendor/opal-oga/ext/pureruby/.
+RSpec.describe "Moxml Opal oga default", if: RUBY_ENGINE == "opal" do
+  let(:context) { Moxml.new }
+
+  it "defaults to :oga under Opal" do
+    expect(Moxml::Config::OPAL_DEFAULT_ADAPTER).to eq(:oga)
+  end
+
+  it "parses XML through the oga adapter" do
+    doc = context.parse("<root><child>text</child></root>")
+    expect(doc.root.name).to eq("root")
+    expect(doc.root.children.first.name).to eq("child")
+  end
+
+  it "decodes entities single-pass" do
+    doc = context.parse("<root>&amp;#38;</root>")
+    expect(doc.root.text).to eq("&#38;")
+  end
+
+  it "serializes back to XML" do
+    xml = '<person name="Alice"><age>30</age></person>'
+    doc = context.parse(xml)
+    serialized = doc.to_xml
+    expect(serialized).to include("person")
+    expect(serialized).to include("Alice")
+  end
+end

data/spec/moxml/signature/algorithms/base64_transform_spec.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "base64"
+
+RSpec.describe Moxml::Signature::Algorithms::Base64Transform do
+  let(:ctx) { Moxml.new(:nokogiri) }
+  let(:transform) { described_class.new(context: ctx) }
+
+  it "decodes base64 octet input" do
+    encoded = Base64.strict_encode64("hello world")
+    expect(transform.transform(encoded)).to eq("hello world")
+  end
+
+  it "strips whitespace before decoding" do
+    encoded = Base64.strict_encode64("hello world").chars.each_slice(4).map(&:join).join("\n")
+    expect(transform.transform(encoded)).to eq("hello world")
+  end
+
+  it "raises TransformError on invalid base64" do
+    expect do
+      transform.transform("!!!not base64!!!")
+    end.to raise_error(Moxml::Signature::TransformError)
+  end
+end

data/spec/moxml/signature/algorithms/digest_base_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+require "base64"
+
+RSpec.describe Moxml::Signature::Algorithms::DigestBase do
+  describe "SHA-256" do
+    let(:digest) { Moxml::Signature::Algorithms::SHA256.new }
+
+    it "computes raw bytes matching OpenSSL" do
+      data = "hello"
+      expect(digest.digest(data)).to eq(OpenSSL::Digest::SHA256.digest(data))
+    end
+
+    it "computes base64-encoded digest matching OpenSSL" do
+      data = "hello"
+      expected = Base64.strict_encode64(OpenSSL::Digest::SHA256.digest(data))
+      expect(digest.digest_base64(data)).to eq(expected)
+    end
+
+    it "matches the FIPS 180-3 test vector for empty string" do
+      # SHA-256("") = e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855
+      expected_hex = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
+      expect(digest.digest("").unpack1("H*")).to eq(expected_hex)
+    end
+
+    it "matches the FIPS 180-3 test vector for 'abc'" do
+      expected_hex = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
+      expect(digest.digest("abc").unpack1("H*")).to eq(expected_hex)
+    end
+  end
+
+  describe "SHA-1" do
+    it "matches the FIPS test vector for 'abc'" do
+      digest = Moxml::Signature::Algorithms::SHA1.new
+      expected_hex = "a9993e364706816aba3e25717850c26c9cd0d89d"
+      expect(digest.digest("abc").unpack1("H*")).to eq(expected_hex)
+    end
+
+    it "is registered under its W3C URI" do
+      klass = Moxml::Signature::Algorithms.lookup(
+        :digest, "http://www.w3.org/2000/09/xmldsig#sha1"
+      )
+      expect(klass).to eq(Moxml::Signature::Algorithms::SHA1)
+    end
+  end
+
+  describe "all five SHA digests" do
+    expected_uris = {
+      "http://www.w3.org/2000/09/xmldsig#sha1" =>
+        [Moxml::Signature::Algorithms::SHA1, 20],
+      "http://www.w3.org/2001/04/xmldsig-more#sha224" =>
+        [Moxml::Signature::Algorithms::SHA224, 28],
+      "http://www.w3.org/2001/04/xmlenc#sha256" =>
+        [Moxml::Signature::Algorithms::SHA256, 32],
+      "http://www.w3.org/2001/04/xmldsig-more#sha384" =>
+        [Moxml::Signature::Algorithms::SHA384, 48],
+      "http://www.w3.org/2001/04/xmlenc#sha512" =>
+        [Moxml::Signature::Algorithms::SHA512, 64],
+    }
+
+    expected_uris.each do |uri, (klass, byte_length)|
+      it "#{uri} resolves to #{klass.name.split('::').last} with #{byte_length}-byte output" do
+        instance = klass.new
+        result = instance.digest("test")
+        expect(result.bytesize).to eq(byte_length)
+      end
+    end
+  end
+end

data/spec/moxml/signature/algorithms/dsa_sha_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+
+RSpec.describe Moxml::Signature::Algorithms::DsaSha do
+  let(:key) { OpenSSL::PKey::DSA.generate(2048) }
+  let(:data) { "the quick brown fox jumps over the lazy dog" }
+
+  it "round-trips DSA-SHA1" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2000/09/xmldsig#dsa-sha1",
+    )
+    sig = algo.sign(data, key)
+    # DSA q for 2048-bit DSA is 256 bits → 32-byte halves → 64-byte raw sig.
+    expect(sig.bytesize).to eq(64)
+    expect(algo.verify(data, key, sig)).to be true
+  end
+
+  it "round-trips DSA-SHA256" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(sig.bytesize).to eq(64)
+    expect(algo.verify(data, key, sig)).to be true
+  end
+
+  it "rejects tampered payload" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify("#{data}!", key, sig)).to be false
+  end
+
+  it "rejects non-DSA keys" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2009/xmldsig11#dsa-sha256",
+    )
+    expect do
+      algo.sign(data, OpenSSL::PKey::RSA.generate(2048))
+    end.to raise_error(Moxml::Signature::SignatureKeyError)
+  end
+end

data/spec/moxml/signature/algorithms/ecdsa_sha_spec.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+
+RSpec.describe Moxml::Signature::Algorithms::EcdsaSha do
+  let(:key) { OpenSSL::PKey::EC.generate("prime256v1") }
+  let(:data) { "the quick brown fox jumps over the lazy dog" }
+
+  %w[
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha1
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha224
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384
+    http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512
+  ].each do |uri|
+    it "#{uri} round-trips sign/verify on P-256" do
+      algo = described_class.new(identifier_uri: uri)
+      sig = algo.sign(data, key)
+      # P-256: 32-byte r ‖ 32-byte s = 64 bytes
+      expect(sig.bytesize).to eq(64)
+      expect(algo.verify(data, key, sig)).to be true
+    end
+  end
+
+  it "rejects tampered payload" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify("#{data}!", key, sig)).to be false
+  end
+
+  it "rejects verification with a different key" do
+    other = OpenSSL::PKey::EC.generate("prime256v1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    sig = algo.sign(data, key)
+    expect(algo.verify(data, other, sig)).to be false
+  end
+
+  it "supports P-384 with 48-byte coordinates" do
+    p384 = OpenSSL::PKey::EC.generate("secp384r1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha384",
+    )
+    sig = algo.sign(data, p384)
+    expect(sig.bytesize).to eq(96)
+    expect(algo.verify(data, p384, sig)).to be true
+  end
+
+  it "supports P-521 with 66-byte coordinates" do
+    p521 = OpenSSL::PKey::EC.generate("secp521r1")
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha512",
+    )
+    sig = algo.sign(data, p521)
+    expect(sig.bytesize).to eq(132)
+    expect(algo.verify(data, p521, sig)).to be true
+  end
+
+  it "rejects non-EC keys" do
+    algo = described_class.new(
+      identifier_uri: "http://www.w3.org/2001/04/xmldsig-more#ecdsa-sha256",
+    )
+    expect do
+      algo.sign(data, OpenSSL::PKey::RSA.generate(2048))
+    end.to raise_error(Moxml::Signature::SignatureKeyError)
+  end
+end

data/spec/moxml/signature/algorithms/enveloped_signature_transform_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+
+RSpec.describe Moxml::Signature::Algorithms::EnvelopedSignatureTransform do
+  let(:ctx) { Moxml.new(:nokogiri) }
+
+  it "is a no-op when signature_element is nil (signing case)" do
+    doc = ctx.parse("<root><child/></root>")
+    root = doc.root
+    transform = described_class.new(context: ctx, signature_element: nil)
+    expect(transform.transform(root)).to equal(root)
+  end
+
+  it "removes the containing signature from a copy (verification case)" do
+    xml = <<~XML.strip
+      <root>
+        <payload>important</payload>
+        <ds:Signature xmlns:ds="http://www.w3.org/2000/09/xmldsig#">
+          <ds:SignedInfo/>
+        </ds:Signature>
+      </root>
+    XML
+    doc = ctx.parse(xml)
+    sig_elem = doc.at_xpath("//ds:Signature",
+                            "ds" => "http://www.w3.org/2000/09/xmldsig#")
+
+    transform = described_class.new(context: ctx, signature_element: sig_elem)
+    result = transform.transform(doc.root)
+
+    expect(doc.at_xpath("//ds:Signature",
+                        "ds" => "http://www.w3.org/2000/09/xmldsig#")).not_to be_nil
+
+    c14n = Moxml::C14n::Exclusive.new
+    canonical = c14n.canonicalize(result)
+    expect(canonical).not_to include("Signature")
+    expect(canonical).to include("important")
+  end
+end

data/spec/moxml/signature/algorithms/hmac_sha_spec.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "moxml/signature"
+require "openssl"
+
+RSpec.describe Moxml::Signature::Algorithms::HmacSha do
+  let(:secret) { "super-secret-shared-key" }
+  let(:data) { "the quick brown fox" }
+
+  describe "HMAC-SHA256" do
+    let(:uri) { "http://www.w3.org/2001/04/xmldsig-more#hmac-sha256" }
+    let(:algo) { described_class.new(identifier_uri: uri) }
+
+    it "produces a verifiable MAC" do
+      mac = algo.sign(data, secret)
+      expect(algo.verify(data, secret, mac)).to be true
+    end
+
+    it "rejects a tampered payload" do
+      mac = algo.sign(data, secret)
+      expect(algo.verify("#{data}!", secret, mac)).to be false
+    end
+
+    it "matches OpenSSL HMAC for the same inputs" do
+      mac = algo.sign(data, secret)
+      expected = OpenSSL::HMAC.digest("SHA256", secret, data)
+      expect(mac).to eq(expected)
+    end
+  end
+
+  describe "HMAC truncation" do
+    let(:uri) { "http://www.w3.org/2001/04/xmldsig-more#hmac-sha256" }
+
+    it "truncates to the specified bit length" do
+      algo = described_class.new(
+        identifier_uri: uri,
+        parameters: { hmac_output_length: 128 },
+      )
+      mac = algo.sign(data, secret)
+      expect(mac.bytesize).to eq(16)
+    end
+
+    it "rejects truncation below hash_bits / 2" do
+      expect do
+        described_class.new(
+          identifier_uri: uri,
+          parameters: { hmac_output_length: 64 },
+        )
+      end.to raise_error(Moxml::Signature::SignatureError)
+    end
+
+    it "rejects truncation below 80 bits even for SHA-1" do
+      expect do
+        described_class.new(
+          identifier_uri: "http://www.w3.org/2000/09/xmldsig#hmac-sha1",
+          parameters: { hmac_output_length: 72 },
+        )
+      end.to raise_error(Moxml::Signature::SignatureError)
+    end
+
+    it "rejects truncation that is not a multiple of 8" do
+      expect do
+        described_class.new(
+          identifier_uri: uri,
+          parameters: { hmac_output_length: 130 },
+        )
+      end.to raise_error(Moxml::Signature::SignatureError)
+    end
+  end
+end