Update tests for #169

Author: kislyuk

.github/workflows/ci.yml

@@ -8,8 +8,8 @@ jobs:
     strategy:
       max-parallel: 8
       matrix:
-        os: [ubuntu-18.04, macos-10.15]
-        python-version: [2.7, 3.5, 3.6, 3.7, 3.8]
+        os: [ubuntu-20.04, macos-10.15]
+        python-version: [3.6, 3.7, 3.8, 3.9]
     steps:
     - uses: actions/checkout@v1
     - name: Set up Python ${{ matrix.python-version }}

test/test.py

@@ -56,10 +56,10 @@ def setUp(self):
                          ecdsa=ec.generate_private_key(curve=ec.SECP384R1(), backend=default_backend()))
 
     def test_basic_signxml_statements(self):
-        with self.assertRaisesRegexp(InvalidInput, "Unknown signature method"):
+        with self.assertRaisesRegex(InvalidInput, "Unknown signature method"):
             signer = XMLSigner(method=None)
 
-        with self.assertRaisesRegexp(InvalidInput, "must be an XML element"):
+        with self.assertRaisesRegex(InvalidInput, "must be an XML element"):
             XMLSigner().sign("x")
 
         digest_algs = {"sha1", "sha224", "sha256", "sha384", "sha512"}
@@ -113,14 +113,14 @@ def resolver(uri):
                 self.assertEqual(_s.tag, "{http://www.w3.org/2000/09/xmldsig#}Signature")
 
                 if method == methods.enveloping:
-                    with self.assertRaisesRegexp(InvalidInput, "Unable to resolve reference URI"):
+                    with self.assertRaisesRegex(InvalidInput, "Unable to resolve reference URI"):
                         XMLVerifier().verify(signed_data, id_attribute="X", **verify_kwargs)
 
-                with self.assertRaisesRegexp(InvalidInput, "Expected a X.509 certificate based signature"):
+                with self.assertRaisesRegex(InvalidInput, "Expected a X.509 certificate based signature"):
                     XMLVerifier().verify(signed_data, hmac_key=hmac_key, uri_resolver=verify_kwargs.get("uri_resolver"))
 
                 if method != methods.detached:
-                    with self.assertRaisesRegexp(InvalidSignature, "Digest mismatch"):
+                    with self.assertRaisesRegex(InvalidSignature, "Digest mismatch"):
                         mangled_sig = signed_data.replace(b"Austria", b"Mongolia").replace(b"x y", b"a b")
                         XMLVerifier().verify(mangled_sig, **verify_kwargs)
 
@@ -141,7 +141,7 @@ def resolver(uri):
                     XMLVerifier().verify("", hmac_key=hmac_key, require_x509=False)
 
                 if sig_alg == "hmac":
-                    with self.assertRaisesRegexp(InvalidSignature, "Signature mismatch"):
+                    with self.assertRaisesRegex(InvalidSignature, "Signature mismatch"):
                         verify_kwargs["hmac_key"] = b"SECRET"
                         XMLVerifier().verify(signed_data, **verify_kwargs)
 
@@ -173,7 +173,7 @@ def test_x509_certs(self):
                 with self.assertRaises(InvalidSignature):
                     XMLVerifier().verify(signed_data, x509_cert=crt, cert_subject_name="test")
 
-                with self.assertRaisesRegexp(InvalidCertificate, "unable to get local issuer certificate"):
+                with self.assertRaisesRegex(InvalidCertificate, "unable to get local issuer certificate"):
                     XMLVerifier().verify(signed_data)
                 # TODO: negative: verify with wrong cert, wrong CA
 
@@ -182,7 +182,7 @@ def test_xmldsig_interop_examples(self):
         for signature_file in glob(os.path.join(os.path.dirname(__file__), "interop", "*.xml")):
             print("Verifying", signature_file)
             with open(signature_file, "rb") as fh:
-                with self.assertRaisesRegexp(InvalidCertificate, "certificate has expired"):
+                with self.assertRaisesRegex(InvalidCertificate, "certificate has expired"):
                     XMLVerifier().verify(fh.read(), ca_pem_file=ca_pem_file)
 
     def test_xmldsig_interop_TR2012(self):
@@ -278,15 +278,15 @@ def cert_resolver(x509_issuer_name, x509_serial_number, x509_digest):
                                          "enveloping-sha224-rsa-sha224", "enveloping-sha256-rsa-sha256",
                                          "enveloping-sha384-rsa-sha384")
                     if signature_file.endswith("expired-cert.xml") or signature_file.endswith("wsfederation_metadata.xml"): # noqa
-                        with self.assertRaisesRegexp(InvalidCertificate, "certificate has expired"):
+                        with self.assertRaisesRegex(InvalidCertificate, "certificate has expired"):
                             raise
                     elif signature_file.endswith("invalid_enveloped_transform.xml"):
                         self.assertIsInstance(e, InvalidSignature)
-                        # with self.assertRaisesRegexp(ValueError, "Can't remove the root signature node"):
+                        # with self.assertRaisesRegex(ValueError, "Can't remove the root signature node"):
                         #    raise
                     elif "md5" in signature_file or "ripemd160" in signature_file:
                         self.assertIsInstance(e, InvalidInput)
-                        # with self.assertRaisesRegexp(InvalidInput, "Algorithm .+ is not recognized"):
+                        # with self.assertRaisesRegex(InvalidInput, "Algorithm .+ is not recognized"):
                         #    raise
                     elif "HMACOutputLength" in sig.decode("utf-8"):
                         self.assertIsInstance(e, (InvalidSignature, InvalidDigest))
@@ -406,8 +406,10 @@ def test_reference_uris_and_custom_key_info(self):
 
             # Test setting both X509Data and KeyInfo
             s4 = XMLSigner().sign(data, reference_uri=reference_uri, key=key, cert=crt, always_add_key_value=True)
-            with self.assertRaisesRegexp(InvalidInput, "Both X509Data and KeyValue found"):
+            try:
                 XMLVerifier().verify(s4, x509_cert=crt)
+            except InvalidSignature as e:
+                self.assertIn("Expected to find 1 references, but found 2", str(e))
             expect_refs = etree.tostring(s4).decode().count("<ds:Reference")
             XMLVerifier().verify(s4, x509_cert=crt, ignore_ambiguous_key_info=True, expect_references=expect_refs)
 
@@ -423,7 +425,7 @@ def test_ws_security(self):
 
         data = etree.parse(os.path.join(wsse_dir, "test", "unit", "client", "files",
                                         "invalid wss resp - changed content.xml"))
-        with self.assertRaisesRegexp(InvalidDigest, "Digest mismatch for reference 0"):
+        with self.assertRaisesRegex(InvalidDigest, "Digest mismatch for reference 0"):
             XMLVerifier().verify(data, x509_cert=crt, validate_schema=False, expect_references=2)
 
     def test_psha1(self):