feature/workflows

1 files changed, 39 insertions, 19 deletions

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())