feature/workflows

6 files changed, 140 insertions, 53 deletions

diff --git a/src/mailman_pgp/pgp/inline.py b/src/mailman_pgp/pgp/inline.py
index 9c19030..458cc26 100644
--- a/src/mailman_pgp/pgp/inline.py
+++ b/src/mailman_pgp/pgp/inline.py
@@ -201,7 +201,10 @@ class InlineWrapper:
     def _decrypt(self, part, key):
         message = PGPMessage.from_blob(part.get_payload())
         decrypted = key.decrypt(message)
-        part.set_payload(decrypted.message)
+        if decrypted.is_signed:
+            part.set_payload(str(decrypted))
+        else:
+            part.set_payload(decrypted.message)
 
     def decrypt(self, key):
         """
diff --git a/src/mailman_pgp/pgp/tests/base.py b/src/mailman_pgp/pgp/tests/base.py
index d561fda..52e5ec4 100644
--- a/src/mailman_pgp/pgp/tests/base.py
+++ b/src/mailman_pgp/pgp/tests/base.py
@@ -42,63 +42,66 @@ def load_key(path):
 class WrapperTestCase(TestCase):
     wrapper = None
 
+    def wrap(self, message):
+        return self.wrapper(message)
+
     def is_signed(self, message, signed):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         self.assertEqual(wrapped.is_signed(), signed)
 
     def sign(self, message, key):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         signed = wrapped.sign(key)
-        signed_wrapped = self.wrapper(signed)
+        signed_wrapped = self.wrap(signed)
         self.assertTrue(signed_wrapped.is_signed())
 
     def sign_verify(self, message, priv, pub):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         signed = wrapped.sign(priv)
-        signed_wrapped = self.wrapper(signed)
+        signed_wrapped = self.wrap(signed)
         for signature in signed_wrapped.verify(pub):
             self.assertTrue(bool(signature))
 
     def verify(self, message, key, valid):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         for signature in wrapped.verify(key):
             self.assertEqual(bool(signature), valid)
 
     def is_encrypted(self, message, encrypted):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         self.assertEqual(wrapped.is_encrypted(), encrypted)
 
     def encrypt(self, message, *keys, **kwargs):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         encrypted = wrapped.encrypt(*keys, **kwargs)
-        encrypted_wrapped = self.wrapper(encrypted)
+        encrypted_wrapped = self.wrap(encrypted)
         self.assertTrue(encrypted_wrapped.is_encrypted())
 
     def encrypt_decrypt(self, message, pub, priv):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         encrypted = wrapped.encrypt(pub)
 
-        encrypted_wrapped = self.wrapper(encrypted)
+        encrypted_wrapped = self.wrap(encrypted)
         decrypted = encrypted_wrapped.decrypt(priv)
-        decrypted_wrapped = self.wrapper(decrypted)
+        decrypted_wrapped = self.wrap(decrypted)
 
         self.assertFalse(decrypted_wrapped.is_encrypted())
         self.assertEqual(decrypted.get_payload(), message.get_payload())
 
     def decrypt(self, message, key, clear):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         decrypted = wrapped.decrypt(key)
-        decrypted_wrapped = self.wrapper(decrypted)
+        decrypted_wrapped = self.wrap(decrypted)
 
         self.assertFalse(decrypted_wrapped.is_encrypted())
         self.assertEqual(decrypted.get_payload(), clear)
 
     def has_keys(self, message, has_keys):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         self.assertEqual(wrapped.has_keys(), has_keys)
 
     def keys(self, message, keys):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         loaded = list(wrapped.keys())
         self.assertEqual(len(loaded), len(keys))
 
@@ -107,13 +110,30 @@ class WrapperTestCase(TestCase):
         self.assertListEqual(loaded_fingerprints, fingerprints)
 
     def sign_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
-        wrapped = self.wrapper(message)
+        wrapped = self.wrap(message)
         encrypted = wrapped.sign_encrypt(sign_key, encrypt_key.pubkey)
-        encrypted_wrapped = self.wrapper(encrypted)
+        encrypted_wrapped = self.wrap(encrypted)
+        self.assertTrue(encrypted_wrapped.is_encrypted())
+
+        decrypted = encrypted_wrapped.decrypt(encrypt_key)
+        decrypted_wrapped = self.wrap(decrypted)
+        self.assertTrue(decrypted_wrapped.is_signed())
+        self.assertFalse(decrypted_wrapped.is_encrypted())
+
+        verification = decrypted_wrapped.verify(sign_key.pubkey)
+        for sig in verification:
+            self.assertTrue(bool(sig))
+        self.assertListEqual(list(decrypted_wrapped.get_signed()),
+                             list(wrapped.get_payload()))
+
+    def sign_then_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
+        wrapped = self.wrap(message)
+        encrypted = wrapped.sign_then_encrypt(sign_key, encrypt_key.pubkey)
+        encrypted_wrapped = self.wrap(encrypted)
         self.assertTrue(encrypted_wrapped.is_encrypted())
 
         decrypted = encrypted_wrapped.decrypt(encrypt_key)
-        decrypted_wrapped = self.wrapper(decrypted)
+        decrypted_wrapped = self.wrap(decrypted)
         self.assertTrue(decrypted_wrapped.is_signed())
         self.assertFalse(decrypted_wrapped.is_encrypted())
 
diff --git a/src/mailman_pgp/pgp/tests/test_inline.py b/src/mailman_pgp/pgp/tests/test_inline.py
index cd18209..a89963a 100644
--- a/src/mailman_pgp/pgp/tests/test_inline.py
+++ b/src/mailman_pgp/pgp/tests/test_inline.py
@@ -18,6 +18,7 @@
 """Tests for the inline wrapper."""
 
 from parameterized import parameterized
+from public import public
 
 from mailman_pgp.pgp.inline import InlineWrapper
 from mailman_pgp.pgp.tests.base import load_key, load_message, WrapperTestCase
@@ -27,6 +28,7 @@ class InlineWrapperTestCase(WrapperTestCase):
     wrapper = InlineWrapper
 
 
+@public
 class TestSigning(InlineWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_cleartext_signed.eml'),
@@ -43,7 +45,7 @@ class TestSigning(InlineWrapperTestCase):
          False)
     ])
     def test_is_signed(self, message, signed):
-        super().is_signed(message, signed)
+        self.is_signed(message, signed)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -52,7 +54,7 @@ class TestSigning(InlineWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_sign(self, message, key):
-        super().sign(message, key)
+        self.sign(message, key)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -63,7 +65,7 @@ class TestSigning(InlineWrapperTestCase):
          load_key('ecc_p256.pub.asc'))
     ])
     def test_sign_verify(self, message, priv, pub):
-        super().sign_verify(message, priv, pub)
+        self.sign_verify(message, priv, pub)
 
     @parameterized.expand([
         (load_message('inline_cleartext_signed.eml'),
@@ -80,9 +82,10 @@ class TestSigning(InlineWrapperTestCase):
          False),
     ])
     def test_verify(self, message, key, valid):
-        super().verify(message, key, valid)
+        self.verify(message, key, valid)
 
 
+@public
 class TestEncryption(InlineWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_encrypted.eml'),
@@ -99,7 +102,7 @@ class TestEncryption(InlineWrapperTestCase):
          False)
     ])
     def test_is_encrypted(self, message, encrypted):
-        super().is_encrypted(message, encrypted)
+        self.is_encrypted(message, encrypted)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -110,9 +113,9 @@ class TestEncryption(InlineWrapperTestCase):
     ])
     def test_encrypt(self, message, keys, **kwargs):
         if isinstance(keys, tuple):
-            super().encrypt(message, *keys, **kwargs)
+            self.encrypt(message, *keys, **kwargs)
         else:
-            super().encrypt(message, keys, **kwargs)
+            self.encrypt(message, keys, **kwargs)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -123,7 +126,7 @@ class TestEncryption(InlineWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_encrypt_decrypt(self, message, pub, priv):
-        super().encrypt_decrypt(message, pub, priv)
+        self.encrypt_decrypt(message, pub, priv)
 
     @parameterized.expand([
         (load_message('inline_encrypted.eml'),
@@ -131,9 +134,10 @@ class TestEncryption(InlineWrapperTestCase):
          'Some encrypted text.\n\n')
     ])
     def test_decrypt(self, message, key, clear):
-        super().decrypt(message, key, clear)
+        self.decrypt(message, key, clear)
 
 
+@public
 class TestKeys(InlineWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_privkey.eml'),
@@ -146,7 +150,7 @@ class TestKeys(InlineWrapperTestCase):
          False)
     ])
     def test_has_keys(self, message, has_keys):
-        super().has_keys(message, has_keys)
+        self.has_keys(message, has_keys)
 
     @parameterized.expand([
         (load_message('inline_privkey.eml'),
@@ -155,4 +159,24 @@ class TestKeys(InlineWrapperTestCase):
          [load_key('rsa_1024.pub.asc')])
     ])
     def test_keys(self, message, keys):
-        super().keys(message, keys)
+        self.keys(message, keys)
+
+
+@public
+class TestCombined(InlineWrapperTestCase):
+    @parameterized.expand([
+        (load_message('clear.eml'),
+         load_key('rsa_1024.priv.asc'),
+         load_key('ecc_p256.priv.asc'))
+    ])
+    def test_sign_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
+        self.sign_encrypt_decrypt_verify(message, sign_key, encrypt_key)
+
+    @parameterized.expand([
+        (load_message('clear.eml'),
+         load_key('rsa_1024.priv.asc'),
+         load_key('ecc_p256.priv.asc'))
+    ])
+    def test_sign_then_encrypt_decrypt_verify(self, message, sign_key,
+                                              encrypt_key):
+        self.sign_then_encrypt_decrypt_verify(message, sign_key, encrypt_key)
diff --git a/src/mailman_pgp/pgp/tests/test_keygen.py b/src/mailman_pgp/pgp/tests/test_keygen.py
index dab6801..5c59614 100644
--- a/src/mailman_pgp/pgp/tests/test_keygen.py
+++ b/src/mailman_pgp/pgp/tests/test_keygen.py
@@ -21,10 +21,12 @@ from unittest import TestCase
 
 from pgpy import PGPKey
 from pgpy.constants import PubKeyAlgorithm
+from public import public
 
 from mailman_pgp.pgp.keygen import ListKeyGenerator
 
 
+@public
 class TesKeygen(TestCase):
     def setUp(self):
         self.keypair_config = {
diff --git a/src/mailman_pgp/pgp/tests/test_mime.py b/src/mailman_pgp/pgp/tests/test_mime.py
index fab50bb..f56c781 100644
--- a/src/mailman_pgp/pgp/tests/test_mime.py
+++ b/src/mailman_pgp/pgp/tests/test_mime.py
@@ -18,6 +18,7 @@
 """Tests for the MIME wrapper."""
 
 from parameterized import parameterized
+from public import public
 
 from mailman_pgp.pgp.mime import MIMEWrapper
 from mailman_pgp.pgp.tests.base import load_key, load_message, WrapperTestCase
@@ -27,6 +28,7 @@ class MIMEWrapperTestCase(WrapperTestCase):
     wrapper = MIMEWrapper
 
 
+@public
 class TestSigning(MIMEWrapperTestCase):
     @parameterized.expand([
         (load_message('mime_signed.eml'),
@@ -37,7 +39,7 @@ class TestSigning(MIMEWrapperTestCase):
          False)
     ])
     def test_is_signed(self, message, signed):
-        super().is_signed(message, signed)
+        self.is_signed(message, signed)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -46,7 +48,7 @@ class TestSigning(MIMEWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_sign(self, message, key):
-        super().sign(message, key)
+        self.sign(message, key)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -57,7 +59,7 @@ class TestSigning(MIMEWrapperTestCase):
          load_key('ecc_p256.pub.asc'))
     ])
     def test_sign_verify(self, message, priv, pub):
-        super().sign_verify(message, priv, pub)
+        self.sign_verify(message, priv, pub)
 
     @parameterized.expand([
         (load_message('mime_signed.eml'),
@@ -68,9 +70,10 @@ class TestSigning(MIMEWrapperTestCase):
          False)
     ])
     def test_verify(self, message, key, valid):
-        super().verify(message, key, valid)
+        self.verify(message, key, valid)
 
 
+@public
 class TestEncryption(MIMEWrapperTestCase):
     @parameterized.expand([
         (load_message('mime_encrypted.eml'),
@@ -79,7 +82,7 @@ class TestEncryption(MIMEWrapperTestCase):
          True)
     ])
     def test_is_encrypted(self, message, encrypted):
-        super().is_encrypted(message, encrypted)
+        self.is_encrypted(message, encrypted)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -90,9 +93,9 @@ class TestEncryption(MIMEWrapperTestCase):
     ])
     def test_encrypt(self, message, keys, **kwargs):
         if isinstance(keys, tuple):
-            super().encrypt(message, *keys, **kwargs)
+            self.encrypt(message, *keys, **kwargs)
         else:
-            super().encrypt(message, keys, **kwargs)
+            self.encrypt(message, keys, **kwargs)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -103,7 +106,7 @@ class TestEncryption(MIMEWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_encrypt_decrypt(self, message, pub, priv):
-        super().encrypt_decrypt(message, pub, priv)
+        self.encrypt_decrypt(message, pub, priv)
 
     @parameterized.expand([
         (load_message('mime_encrypted.eml'),
@@ -111,9 +114,10 @@ class TestEncryption(MIMEWrapperTestCase):
          'Some encrypted text.\n')
     ])
     def test_decrypt(self, message, key, clear):
-        super().decrypt(message, key, clear)
+        self.decrypt(message, key, clear)
 
 
+@public
 class TestKeys(MIMEWrapperTestCase):
     @parameterized.expand([
         (load_message('mime_privkey.eml'),
@@ -126,7 +130,7 @@ class TestKeys(MIMEWrapperTestCase):
          False)
     ])
     def test_has_keys(self, message, has_keys):
-        super().has_keys(message, has_keys)
+        self.has_keys(message, has_keys)
 
     @parameterized.expand([
         (load_message('mime_privkey.eml'),
@@ -135,9 +139,10 @@ class TestKeys(MIMEWrapperTestCase):
          [load_key('rsa_1024.pub.asc')])
     ])
     def test_keys(self, message, keys):
-        super().keys(message, keys)
+        self.keys(message, keys)
 
 
+@public
 class TestCombined(MIMEWrapperTestCase):
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -145,4 +150,13 @@ class TestCombined(MIMEWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_sign_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
-        super().sign_encrypt_decrypt_verify(message, sign_key, encrypt_key)
+        self.sign_encrypt_decrypt_verify(message, sign_key, encrypt_key)
+
+    @parameterized.expand([
+        (load_message('clear.eml'),
+         load_key('rsa_1024.priv.asc'),
+         load_key('ecc_p256.priv.asc'))
+    ])
+    def test_sign_then_encrypt_decrypt_verify(self, message, sign_key,
+                                              encrypt_key):
+        self.sign_then_encrypt_decrypt_verify(message, sign_key, encrypt_key)
diff --git a/src/mailman_pgp/pgp/tests/test_wrapper.py b/src/mailman_pgp/pgp/tests/test_wrapper.py
index fb7f0bb..14f40fc 100644
--- a/src/mailman_pgp/pgp/tests/test_wrapper.py
+++ b/src/mailman_pgp/pgp/tests/test_wrapper.py
@@ -17,6 +17,7 @@
 
 """Tests for the combined wrapper."""
 from parameterized import parameterized
+from public import public
 
 from mailman_pgp.pgp.tests.base import load_key, load_message, WrapperTestCase
 from mailman_pgp.pgp.wrapper import PGPWrapper
@@ -26,6 +27,7 @@ class PGPWrapperTestCase(WrapperTestCase):
     wrapper = PGPWrapper
 
 
+@public
 class TestSigning(PGPWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_cleartext_signed.eml'),
@@ -46,7 +48,7 @@ class TestSigning(PGPWrapperTestCase):
          False)
     ])
     def test_is_signed(self, message, signed):
-        super().is_signed(message, signed)
+        self.is_signed(message, signed)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -55,7 +57,7 @@ class TestSigning(PGPWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_sign(self, message, key):
-        super().sign(message, key)
+        self.sign(message, key)
 
     @parameterized.expand([
         (load_message('inline_cleartext_signed.eml'),
@@ -72,9 +74,10 @@ class TestSigning(PGPWrapperTestCase):
          False)
     ])
     def test_verify(self, message, key, valid):
-        super().verify(message, key, valid)
+        self.verify(message, key, valid)
 
 
+@public
 class TestEncryption(PGPWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_encrypted.eml'),
@@ -93,7 +96,7 @@ class TestEncryption(PGPWrapperTestCase):
          False)
     ])
     def test_is_encrypted(self, message, encrypted):
-        super().is_encrypted(message, encrypted)
+        self.is_encrypted(message, encrypted)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -104,9 +107,9 @@ class TestEncryption(PGPWrapperTestCase):
     ])
     def test_encrypt(self, message, keys, **kwargs):
         if isinstance(keys, tuple):
-            super().encrypt(message, *keys, **kwargs)
+            self.encrypt(message, *keys, **kwargs)
         else:
-            super().encrypt(message, keys, **kwargs)
+            self.encrypt(message, keys, **kwargs)
 
     @parameterized.expand([
         (load_message('clear.eml'),
@@ -117,7 +120,7 @@ class TestEncryption(PGPWrapperTestCase):
          load_key('ecc_p256.priv.asc'))
     ])
     def test_encrypt_decrypt(self, message, pub, priv):
-        super().encrypt_decrypt(message, pub, priv)
+        self.encrypt_decrypt(message, pub, priv)
 
     @parameterized.expand([
         (load_message('inline_encrypted.eml'),
@@ -125,9 +128,10 @@ class TestEncryption(PGPWrapperTestCase):
          'Some encrypted text.\n\n')
     ])
     def test_decrypt(self, message, key, clear):
-        super().decrypt(message, key, clear)
+        self.decrypt(message, key, clear)
 
 
+@public
 class TestKeys(PGPWrapperTestCase):
     @parameterized.expand([
         (load_message('inline_privkey.eml'),
@@ -146,7 +150,7 @@ class TestKeys(PGPWrapperTestCase):
          False)
     ])
     def test_has_keys(self, message, has_keys):
-        super().has_keys(message, has_keys)
+        self.has_keys(message, has_keys)
 
     @parameterized.expand([
         (load_message('inline_privkey.eml'),
@@ -159,4 +163,24 @@ class TestKeys(PGPWrapperTestCase):
          [load_key('rsa_1024.pub.asc')])
     ])
     def test_keys(self, message, keys):
-        super().keys(message, keys)
+        self.keys(message, keys)
+
+
+@public
+class TestCombined(PGPWrapperTestCase):
+    @parameterized.expand([
+        (load_message('clear.eml'),
+         load_key('rsa_1024.priv.asc'),
+         load_key('ecc_p256.priv.asc'))
+    ])
+    def test_sign_encrypt_decrypt_verify(self, message, sign_key, encrypt_key):
+        self.sign_encrypt_decrypt_verify(message, sign_key, encrypt_key)
+
+    @parameterized.expand([
+        (load_message('clear.eml'),
+         load_key('rsa_1024.priv.asc'),
+         load_key('ecc_p256.priv.asc'))
+    ])
+    def test_sign_then_encrypt_decrypt_verify(self, message, sign_key,
+                                              encrypt_key):
+        self.sign_then_encrypt_decrypt_verify(message, sign_key, encrypt_key)