ENGINE-633: default key import tests evolution

test/src/DefaultFromEmailTest.cc

@@ -10,7 +10,7 @@
 
 #include <gtest/gtest.h>
 
-#define DEFAULT_FROM_TEST_GEN 1
+#define DEFAULT_FROM_TEST_GEN 0
 
 namespace {
 
@@ -758,3 +758,837 @@ TEST_F(DefaultFromEmailTest, check_pEp_v2_1_import_two_alternate_available) {
 TEST_F(DefaultFromEmailTest, check_pEp_v2_2_import_two_alternate_available) {
 }
 
+///////////////////////////////////////////////////////////////
+// New start with canonical emails added for fdik's tests
+///////////////////////////////////////////////////////////////
+
+// Identity Key:
+// Bob: known pEp partner
+// Carol: known OpenPGP partner
+// Sylvia: unknown pEp partner
+// John: unknown OpenPGP partner
+
+// Case 1: Partner didn't have our key
+
+// A. Test successful cases
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_carol) {
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_john) {
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_sylvia) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAliceUnencrypted.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_EQ(status, PEP_UNENCRYPTED);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_bob) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAliceUnencrypted.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_EQ(status, PEP_UNENCRYPTED);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+// B. Test failures
+
+// Failure case 1) No key attached
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_carol_no_key) {
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_john_no_key) {
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_sylvia_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAliceUnencrypted_NoKey.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_EQ(status, PEP_UNENCRYPTED);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_unencrypted_key_import_bob_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAliceUnencrypted_NoKey.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_EQ(status, PEP_UNENCRYPTED);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+// Case 2: Partner had our key; we did not have theirs
+
+// A. Test successful cases
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_2.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_2) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_2.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_1) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_1.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_1) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_1.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_0) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_0.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_0) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_0.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0.eml";
+    message* infile = NULL;
+    status = vanilla_read_file_and_decrypt(session, &infile, filename);
+    ASSERT_OK;
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NOTNULL(recip->fpr);
+    ASSERT_STREQ(recip->fpr, sender_info.fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_pEp_unconfirmed);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+
+// B. Test failures
+
+// Failure case 1) No key attached
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_carol_no_key) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_john_no_key) {
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_2_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_2_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_2_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_2_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_1_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_1_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_1_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_1_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_2_0_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_2_0_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_2_0_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_2_0_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_sylvia_1_0_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::SYLVIA];
+    pEp_identity* recip = NULL;
+
+    // Make sure identity doesn't exist - do NOT use update_identity, which will create it in the DB
+    PEP_STATUS status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+    // And also not in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now have a blank slate. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2SylviaToAlice_1_0_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}
+
+TEST_F(DefaultFromEmailTest, check_encrypted_key_import_bob_1_0_no_key) {
+    pEp_identity* alice = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::ALICE);
+    const TestUtilsPreset::IdentityInfo& sender_info = TestUtilsPreset::presets[TestUtilsPreset::BOB];
+
+    // We need recip to exist in DB without a known key.
+    pEp_identity* recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    PEP_STATUS status = set_identity(session, recip);
+    ASSERT_OK;
+
+    // Make sure identity exists
+    free_identity(recip);
+    recip = NULL;
+    status = get_identity(session, sender_info.email, sender_info.user_id, &recip);
+    ASSERT_OK;
+    free_identity(recip);
+    recip = NULL;
+    // And *not* in TOFU form
+    string TOFU = string("TOFU_") + sender_info.email;
+    status = get_identity(session, sender_info.email, TOFU.c_str(), &recip);
+    ASSERT_EQ(status, PEP_CANNOT_FIND_IDENTITY);
+
+    // Ok, we now the desired state. Run the import mail fun.
+    const char* filename = "test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey.eml";
+    message* infile = NULL;
+    PEP_rating rating = PEP_rating_undefined;
+    status = vanilla_read_file_and_decrypt_with_rating(session, &infile, filename, &rating);
+    ASSERT_EQ(status, PEP_DECRYPTED);
+    ASSERT_EQ(rating, PEP_rating_unreliable);
+
+    // Ensure we now have a default key for recip - NOTE: IF THE NAME IS NULL OR DOES NOT MATCH THE TOFU INPUT NAME,
+    // WE WILL GET NO KEY. THIS IS APPARENTLY BY DESIGN.
+    //
+    // I did ask. Often. ;)
+    recip = new_identity(sender_info.email, NULL, sender_info.user_id, sender_info.name);
+    ASSERT_NOTNULL(recip);
+    status = update_identity(session, recip);
+    ASSERT_NULL(recip->fpr);
+    ASSERT_EQ(recip->comm_type, PEP_ct_key_not_found);
+
+    free_message(infile);
+    free_identity(alice);
+    free_identity(recip);
+}

test/src/GenerateMailsToMessageTypeTest.cc

@@ -10,7 +10,7 @@
 
 #include <gtest/gtest.h>
 
-#define GMTMTT_WRITEOUT 0
+#define GMTMTT_WRITEOUT 1
 namespace {
 
 	//The fixture for GenerateMailsToMessageTypeTest
@@ -240,7 +240,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_2_
 /////// No keys
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_unencrypted_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAliceUnencrypted.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAliceUnencrypted_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateOnlyPartnerIdentity(session, TestUtilsPreset::ALICE);
     message* msg = gen_outgoing_message_template(me, alice);
@@ -249,7 +249,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_unen
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_unencrypted_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAliceUnencrypted.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAliceUnencrypted_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateOnlyPartnerIdentity(session, TestUtilsPreset::ALICE);
     message* msg = gen_outgoing_message_template(me, alice);
@@ -258,7 +258,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_unen
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_OpenPGP_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_OpenPGP.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_OpenPGP_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateAndSetOpenPGPPartnerIdentity(session, TestUtilsPreset::ALICE, true, false);
     message* msg = gen_outgoing_message_template(me, alice);
@@ -267,7 +267,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_Open
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_OpenPGP_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_OpenPGP.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_OpenPGP_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateAndSetOpenPGPPartnerIdentity(session, TestUtilsPreset::ALICE, true, false);
     message* msg = gen_outgoing_message_template(me, alice);
@@ -276,7 +276,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_Open
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_1_0_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_1_0.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_1_0_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 1;
@@ -288,7 +288,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_1_0_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_1_0_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_1_0.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_1_0_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, false);
     int alice_major = 1;
@@ -300,7 +300,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_1_0_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_0_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_0.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_0_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;
@@ -313,7 +313,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_0_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_0_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_0.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_0_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;
@@ -326,7 +326,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_0_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_1_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_1.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_1_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;
@@ -339,7 +339,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_1_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_1_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_1.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_1_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;
@@ -352,7 +352,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_1_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_2_bob_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_2.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "BobToAlice_2_2_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::BOB);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;
@@ -365,7 +365,7 @@ TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_2_
 }
 
 TEST_F(GenerateMailsToMessageTypeTest, check_generate_mails_to_message_type_2_2_sylvia_no_attached_key) {
-    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_2.eml";
+    string filename = string("test_mails/CanonicalFrom") + PEP_VERSION + "SylviaToAlice_2_2_NoKey.eml";
     pEp_identity* me = TestUtilsPreset::generateAndSetPrivateIdentity(session, TestUtilsPreset::SYLVIA);
     pEp_identity* alice = TestUtilsPreset::generateAndSetpEpPartnerIdentity(session, TestUtilsPreset::ALICE, true, true);
     int alice_major = 2;

test/src/TestUtilities.cc

@@ -543,7 +543,12 @@ PEP_STATUS vanilla_encrypt_and_write_to_file(PEP_SESSION session, message* msg,
  
 // For when you ONLY care about the message
 PEP_STATUS vanilla_read_file_and_decrypt(PEP_SESSION session, message** msg, const char* filename) {
-    if (!session || !msg || !filename)
+    PEP_rating rating = PEP_rating_undefined;
+    return vanilla_read_file_and_decrypt_with_rating(session, msg, filename, &rating);
+}
+
+PEP_STATUS vanilla_read_file_and_decrypt_with_rating(PEP_SESSION session, message** msg, const char* filename, PEP_rating* rating) {
+    if (!session || !msg || !filename || !rating)
         return PEP_ILLEGAL_VALUE;
     PEP_STATUS status = PEP_STATUS_OK;
     std::string inbox = slurp(filename);
@@ -556,9 +561,8 @@ PEP_STATUS vanilla_read_file_and_decrypt(PEP_SESSION session, message** msg, con
     message* dec_msg = NULL;
     stringlist_t* keylist = NULL;
     PEP_decrypt_flags_t flags = 0;
-    PEP_rating rating;
 
-    status = decrypt_message(session, enc_msg, &dec_msg, &keylist, &rating, &flags);
+    status = decrypt_message(session, enc_msg, &dec_msg, &keylist, rating, &flags);
     if (dec_msg)
         *msg = dec_msg;
     free_stringlist(keylist); // no one cares
@@ -567,7 +571,6 @@ PEP_STATUS vanilla_read_file_and_decrypt(PEP_SESSION session, message** msg, con
 }
 
 
-
 int util_delete_filepath(const char *filepath,
                          const struct stat *file_stat,
                          int ftw_info,

test/src/TestUtilities.h

@@ -191,6 +191,7 @@ message* string_to_msg(std::string infile);
 // For when you ONLY care about the message
 PEP_STATUS vanilla_encrypt_and_write_to_file(PEP_SESSION session, message* msg, const char* filename, PEP_encrypt_flags_t flags = 0);
 PEP_STATUS vanilla_read_file_and_decrypt(PEP_SESSION session, message** msg, const char* filename);
+PEP_STATUS vanilla_read_file_and_decrypt_with_rating(PEP_SESSION session, message** msg, const char* filename, PEP_rating* rating);
 
 int util_delete_filepath(const char *filepath, 
                          const struct stat *file_stat, 

test/test_mails/CanonicalFrom2.2BobToAliceUnencrypted.eml

@@ -3,10 +3,52 @@ To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: This is a canonical mail from someone to Alice
 X-pEp-Version: 2.2
 MIME-Version: 1.0
+Content-Type: multipart/mixed; boundary="35090b856c4242f14c2f6ed5484850cf"
+
+--35090b856c4242f14c2f6ed5484850cf
 Content-Type: text/plain
 Content-Transfer-Encoding: 7bit
 
 Fa una canzona senza note nere
 Se mai bramasti la mia grazia havere
 Falla d'un tuono ch'invita al dormire,
-Dolcemente, dolcemente facendo la finire.
+Dolcemente, dolcemente facendo la finire.
+--35090b856c4242f14c2f6ed5484850cf
+Content-Type: application/pgp-keys
+Content-Transfer-Encoding: base64
+Content-Disposition: attachment; filename="sender_key.asc"
+
+LS0tLS1CRUdJTiBQR1AgUFVCTElDIEtFWSBCTE9DSy0tLS0tCgp4c0JOQkZWNFBsOEJDQUN1dWtR
+THdzSGZ0SDVqa1ZzU0w3Q09GaGFtTnNFRThsWjhNRzFmMVJ4NXp0UHVaVG5hCllYeVdPRGdwajJC
+eHowVGNQK1ExN0diTEtzZTdUV0QxazlpMVJ6TFd6OFpTQ0xZcTJUdGpMV1BsZVZ1R0dXZXEKWTN0
+VFdIQy9uRmJpdm9sTlBBMG1MMjAzOFRHZEJvbFBhWmlQWjRQOHd1UVZZTmZEcWk0dXRjZXpHRE5T
+OE9IaApFUGhmeUtLb1NNNzlITG9VUGM2eHNmaW14UE1yeWxJL2k4YkZ2ZkRZejV2bXlkZWZ2QXhO
+aHFqTEgzR21oajFwCm5JbnNyYUVpeWg3WTJ6QXhDZnI2aEQ5bmt5N1dpeEJpbktGRmhRcGNVdTFv
+K0llNlVHd0xWYlR5Uk1PY1Jzb2IKeWFocUEvbTJIZkRSajFZK244SEhxc1FrQjJCdG1NWVhsYTNq
+QUJFQkFBSE5RWEJGY0NCVVpYTjBJRUp2WWlBbwpkR1Z6ZENCclpYa3NJR1J2YmlkMElIVnpaU2tn
+UEhCbGNDNTBaWE4wTG1KdllrQndaWEF0Y0hKdmFtVmpkQzV2CmNtYyt3c0NQQkJNQkFnQWlCUUpW
+ZUQ1ZkFoc0RCZ3NKQ0FjREFnWVZDQUlKQ2dzRUZnSURBUUllQVFJWGdBQWgKQ1JCWnYvU0l5Y0x1
+T1JZaEJML050L01CM3U2NytVZnlsbG0vOUlqSnd1NDVwSGtJQUtQY1RyS1EycU1aTGsvTwpDRmg4
+c215anFQM25oRE12QTZqTlBOVC9mOGRZZmlVTGNtWit2U2tZam5VcG5wZDYrdW5jMzFMRkdxdTRr
+SVZHCjNBMTRmZTZNaUFPSDlRY0pRU3cvLzUzdmhJNTZjZ0ZnWlFvVFU0bWFIejh0QjJRMUp6b2sx
+M01tTU5aMHA2SHAKd0F3VzlhTzc4MnEyWCtYUVVheWxCVDEyWUl5M09RcUNiQ2dwbGJucG9SVm5h
+VlBHbzBTalZwRDZVdXMyNTRHcgpUOURtUUJVVE5RYnRSK2JYM0JlTlo2Y1F4NTRTVmZkUUFhNTBz
+bTV5VEh1NFB4Yi9JSENxdEVCdG9KSjVsL3BGClVFdlAzcDZTTmF0Vjh5ZWFPUSs1QTgrM2x5ejN4
+SEZCT25HVHR2ckV0cFpmS2FFRHB4aFQ0VUJiZ09sdU44bU0KeFlnVU53ck93RTBFVlhnK1h3RUlB
+TXBEWkpYcUNOSGszcjNGVjJJSnA1K1BDaHV0ZEhXZUs0RWNFMU5jd25BKwpUYkcvNTd0OWpieEVy
+VUhNNE5nTE1HR21XMjlHZ0p3bUwxTHRHckxQeldkdkdmRC9WTm9xMmZwME1PRms5VWVNCjNlOXF3
+TzU0enJGTVI4U0tFMXpRN0IvakRQMUlHTzZ0NTFSV1IxUEZUc1hGS0JVL1hSMDdHRjIyU05hTVpi
+VU0KWHBhVmdEd0VBZ1IxdW1pRjRrZlBjMFdTRTlEd09YT2pzaWg3YTN1K3RQTzF3RmZYV2paNzRV
+ODZyVkthRVN2dgp6QnRFNERJSlVCY3I3eW9PSGpNT3J5SUF4a3I4cWRtdWJxay9UVDZJRkZ4djRs
+Q0NmY2FmNkZUU1dBVGRnSDJRCkVrdDVab2ZFUTgyZWMwMjliOEV5WG5keTEvd2luNm5Pa0RVcjlM
+YmNwVHNBRVFFQUFjTEFkZ1FZQVFJQUNRVUMKVlhnK1h3SWJEQUFoQ1JCWnYvU0l5Y0x1T1JZaEJM
+L050L01CM3U2NytVZnlsbG0vOUlqSnd1NDVhbThILzNUKwpMRncwWWtlYmxUSWVWb1RwOVV2REp4
+MllTMWdFT255UGZ5c1lJQWo0WUdPc3dJTE16ekxyY3diRUpWZUQra0Y5CjlIZmZTRENhOHhtR01Z
+emUyZW54ZTdyUGJ0ZE4vaGs4eGtCKy8rT3lSdEhrazBtaWtMNmhHamRmdWpQemdXU24KTURWdXNS
+MnZwWVNFdVp5Umxkem5zdjBSVU1MbkFibzBHN2Nvd3pkMmhySWNLczRTVnhRWlJkMGFoY3k4YmdD
+WgpuamxYbldpcjNUNDBZWUJic1laSW5GSVZhZHU2bDBBcVE2WkZKSS9ZVysrY2doT3FRTTZLVHVy
+T3VjaDdKeGNuCm9jSU1qSzM2VXo1VHpQT2dkU3grQ0JNRW1qcXhDVW5SNTV4US9KNTBpSTBjbjYy
+dDNiQ1AwVlRabUYvQkpEQmkKQXM2RWVKVm5HQlVvU1VET2tFST0KPXhyM3kKLS0tLS1FTkQgUEdQ
+IFBVQkxJQyBLRVkgQkxPQ0stLS0tLQo=
+
+--35090b856c4242f14c2f6ed5484850cf--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0.eml

@@ -3,48 +3,106 @@ To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: =?utf-8?Q?p=E2=89=A1p?=
 X-pEp-Version: 2.2
 MIME-Version: 1.0
-Content-Type: multipart/encrypted; boundary="5a254ac466074e4823f1b15325c02da"; 
+Content-Type: multipart/encrypted; boundary="57040631395187c95063b5482f9487c"; 
  protocol="application/pgp-encrypted"
 
---5a254ac466074e4823f1b15325c02da
+--57040631395187c95063b5482f9487c
 Content-Type: application/pgp-encrypted
 
 Version: 1
---5a254ac466074e4823f1b15325c02da
+--57040631395187c95063b5482f9487c
 Content-Type: application/octet-stream
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline; filename="msg.asc"
 
 -----BEGIN PGP MESSAGE-----
 
-wcBMA4rbkTfsG51OAQgAh9kg1PaL3xTkmbC4257Cyg2eK+OeOSUCFY2+hyXG6/0D
-ZwhlTKAvo56OoNRrJTc+DX4UaXGSe8Q2Kc6f+8mBcNHJOYPFhLQQb5tQlXypXCXM
-Mq3cXyqZlTqU283JffVonTer3LwCUzwTdezN0WAw0IS9pMy7VjVo367G6VSFstRn
-29NFmc5eNooIycVgF0AOJC1tNlKKCBB5A75lGVsXJIHuIejGNy1tjdh+Z7wcKM1D
-kQ4Z+zq06GazBq5+4Oynoi9NOe5BXo8FvR19VlFY7fOOBgykvnnGohMX8J246Okp
-F2B3xFoBw0ha1fA21s1rM/OfCESX6/DKEFWinptOvsHATANaAgXZcwg/TQEH/0th
-el2KSKP4r+7K4frVbUenQ/n0wpYbWrmLZDoGrmHZfFsCpIZXeEzVx4BDfv7IYLTI
-ZVQKzd7fiZbwcDRka04bbRA6cZRUl0GCK+Jn+jVeEbzXYe14jlSRsMdRs4H5xLIy
-rGfELBrIONvP92lyu/1BpPSRPpMsVxApV2pJuM66bNQRbbXIlLn7UEsCMM5X7sbb
-hHUZqFuaMu1VaQlVNW7RMyxFKwYKXZhVswSu/gyb6vmyKBIb37pxQnBF+gTlht3k
-SdWIATLgFAKTdUEz87Hvzixj7bFXH/4+0Z/FuvK5VnWNdXv9XVGa0q6baYq16clh
-oqCZ1ddakaMFMyqF3fHSwiEBM3sscXbioR5CCLJJlbX1F4SUGP0UmMpihwp+wPu+
-NvBHcWZDZWKf46UH1Hml36baOr7zfjYATU4UOAsy7iHXoG0+iJpV1v4yGN4nENk7
-40ODqTjBjX5sdla6t/d59+U00ebA5+aZIKC1ZWnqFmnXx7cpHrpQK/y0RlKsc7Sg
-ZM7f2jgpgpq3J3cYt3JoOYJFyukWcyE6LaZ5bR7hekxHczrOL0FnCb98xJGue7pj
-0hsE5DxjPDOQx4aXWwnmC/ozkZC76eCH1Fu4/WaY5PwCehjUnuCGwc3c9z6bUX4t
-JUGX47GVRDodrOIrXVb+YOkr3mX05ez0Q+yyGnwdQqF2yXWAlcWcvqRT/listTwt
-WWwu5lRaqEPF4kg/cBj79J9PcQvaSXj9NxbiKXf4vVpE0fjtixZuc5DBUS+iJmjB
-asf2esejGFa7Q0oKiiatcxoOFVNYVhur4O85zdolNsllxZ+jnazGBLihsEEq+bg5
-hUK9BMtuRVFsmm1QNOrMwMyGQcN290yKx2eH5d72+hP3crE1GVknVxDRqYZ/PyaB
-iIbaMEWOA3IcoxrIoCUTf4j+cvvFLZuZcK9xM9GtDez0HQECfSdiFoEW9OjvmiLA
-WEkQW06gI8t9/STRo5nVjJBqQU0JJ2jQrPGiTU8RYelEWWKneIbb5oQAsaY6Vi8v
-mvGCvoYI8d634jVaKirmf3iOatXuXTRaHeS7GlNLdcaex2+wqhi4JsSMenGo3h8O
-TGKpJGESCpDOjR9C7RnYtNGEI3FJhiLa8Cbii+PUBcsx8beBLbO9RL9tip+V2zIF
-adz9zFKJdGyVP/xoNMxPF+AYx/s9H/rk4q0mizpbuhfRUyTIBpV5t8K852Pl90v5
-cva3iN8+DOdWg/HAFyYcXfeUlhXAWsHZO6lvssPAwWqGSbMIO9oS5wbAPNJciSTX
-5L1fXzI/7LTqpwH6Do1HEQNfZNQ8flOTPKU4L0iD+9B+Hw==
-=uTX6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+=LA1h
 -----END PGP MESSAGE-----
 
---5a254ac466074e4823f1b15325c02da--
+--57040631395187c95063b5482f9487c--

test/test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey.eml

@@ -3,48 +3,48 @@ To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: =?utf-8?Q?p=E2=89=A1p?=
 X-pEp-Version: 2.2
 MIME-Version: 1.0
-Content-Type: multipart/encrypted; boundary="1dfecef114c8147d142d89d360f81b05"; 
+Content-Type: multipart/encrypted; boundary="5cbc4b0218c670f62c2d62f212ee0942"; 
  protocol="application/pgp-encrypted"
 
---1dfecef114c8147d142d89d360f81b05
+--5cbc4b0218c670f62c2d62f212ee0942
 Content-Type: application/pgp-encrypted
 
 Version: 1
---1dfecef114c8147d142d89d360f81b05
+--5cbc4b0218c670f62c2d62f212ee0942
 Content-Type: application/octet-stream
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline; filename="msg.asc"
 
 -----BEGIN PGP MESSAGE-----
 
-wcBMA4rbkTfsG51OAQf/fwYM5PyP2eNhLWYq+qwtW0+NycGOrhVC9ZbL/iiA8Mqb
-SFAj5s7pBkoIgc7w64lUQzZzeMuNnVMA5rHDyaRIYNIptLWYbZmQ+XvGGFFZNmdB
-IwIl6+gbbLhNsywFUOWuJPE3CWHE0JinJrMu+H5MfepydWv8rmWhKnLn66PR3BoV
-8KaNSvZmYJkg7WnZklx69AmQhuE5LH1w/Dtp0YVO8avvFVqnyFcG6V9LXv870R+/
-xBB5V6gWFEHjjEbaRJt/7GPelAWFoTkIoI9RKnTLGWuA0FYf8E3Oyh/9XdjVa4lH
-zBhklgJrCjuOJ1gJhnA67nFSbCZiQAlblQiqmY4P3sHATANaAgXZcwg/TQEH/jja
-D7uhsSEzcCeeseWBN1nbmMQLspbiHSnVHdOVcF2hBsoeclUD0b/hmjJI3/esbDT5
-vbq5agztID+3/sFWh1/qiVaCwveIkM84lC0SVlYFWwlEpetQSv0pvd2x/auWSYH/
-T4YyjFJsb+jaCkCyeAn3Mz2xQ6G6eY4b48BxLG8xCpt1MaRpHxX++xdp4BYBxbr8
-n2qRrqJSNDlGLCo/BFXZxft0fFXWYrELXba83jOqE7vziUtD/09F21FzWG/kUlLq
-UEGKf2SVQcDgn+pAlX3E1vGrcjOHBaixzDkAv4ZVBaUyOohluSREF6Zi+OMlkKi1
-2SQqvgCPWMbtzHsWzpHSwiEBEe4W+vLuw+ttNlCXVK8KQwMHgvaUVenZL49oIkLt
-FNOyYew24XsX4+iVurMSI2xLJTjYyidXhKj6iFY/sOpOLrvPBS5lNdGNU2mz40ZM
-1ncnq1X1eLPBA/aeFyc5M5vpV1m9QGBU357dZCSUi8T5RDUBj/3tZIeQR7vi5ou/
-CVC7bB4f114TKyqZ+1DRg7jdSfmoQDGcFGSZ4H7MUkzkk7MGka/T6ViUDgcPhEie
-muPmf6xlgOXL5HeqAGJ1Qq2qs5yAJSsGJ3TZe+8XbuaPIcMFqq1B9CQiKnzuQh8H
-JcIsceFgXPH/qArhw8XcVu6Sboe7Q6Wrupd9ww/1G2xQ2sPeLC6crjzpI0lMijzj
-3Sp1QglMI+u85o1XOCBWVpFikJBzI91ZVsWesNG3ydtL/BPs6GXw+TJ0SiR0tuQQ
-4lRt5WFbdnxqmkZQeNH+n/6xRAPfKL9Y38AqgdKDrG1efGo1I9/J0xHria3+plXK
-bADv+PXoudT6CgZceLE8lekS261dbTrltVB7IfE1hsWHFuZr+kRR/6BglXKzVBIa
-BV+SkppXwQhIpCWE047vq9Cq5GWJxuNmZy8b9ZTnzAE0hT/ctsA2SpXg7SpUbGJv
-FR70YooTM+yfzyzY6yGz/lhqh+5oL1IkYN/TXdGPOVyQIg8pzhTQeOnZC7MZKOQF
-qhqYHe63doYV7TfmNTCqeOydyS1SIqnjTJAFPwPcShXNLWaHxV/AY/aHC3s0TDCR
-F5VXiCZfXCcjbUouSVgwKr6waGHTpf90k/O4s2bxTdnZb+4ClbuwBFmEvqqzwJct
-R06fpXvQjseQDeLK4ntDtg+5Tw4kAB+uR4OtftB5aIxE1ntHBbmMg1SeXX3GNSYI
-8DzNSF90L2574AagZUiwUut9WXkkfEdyfS9s3pvXT8+uIk5KBQvw40H64Hf7A1mR
-y+A8p/6T0la1t3sZcA4xh2TqcctAoTlM++86r6ZM9HiRVA==
-=7WMk
+wcBMA4rbkTfsG51OAQf/RFDxoBRVT3avOsnS+lp2ILpKwYZtcZUXKLyeC5G2OvEJ
+NSDzlVS078ClF3mmCBGNIn034hfu2eUa2zoAsHd5xgpw3Xc1rGmtYvhnzTCxEp5q
+9tmhec4Bz7QKm1n6P1WWHUicWDC4R3SeO9vG13SwINpqj6f1K/D9/EoGulpKf28u
+ev2cy5phb66wGxr1V8eGqzf7GJ0EERdhXV7Nvh9OVSdnefAN57kX4DsWD84XH4sa
+vD88U0PatQ3y9pXrIVFuI9iVOJerrPlPA/y/7PB95cJgtBunC0AXlqgxR8kCSdZO
+QgvVpFo9eCUjpW84gL1YmPAZHvn9O4z0tP0lq4JGE8HATANaAgXZcwg/TQEIAIU5
+G/XiZJFvUNR+dqqOicTXgyKN17LzdS2aGiNK8qSkv6MkXo7x8TDdu5VrEdXPforX
+scF20aSOEB2bAeb7Rqo9g2Rmh+kjaRzoO19Fuct0hf/Vg1VGmZHs31Fws95MJzjs
+Msfa/jnzky7aCcla8Q7fHHcfZu8flJDWlXjbuo7kyaCrEgOVTdlkZBywWueVsxRA
+NIYY//hjQ0O1zR37N5OvxRva5NhpYPbA6qhIUew4gdrUgxHfAxT8XSWwKecZnHRk
++ODPpZxKqXyvKZPLMG4Hhu6Gm1REWVMxt+eeje9KxUn5+X5Na8LvkWzSFPpj36fS
+La3XnQ37Rl6o8Hem5snSwiEB9jGxrHKeBLhUQGDMCVQj6eA5KjQAvxhrPsFfh+xT
+Z48WWNiNmnEP2IKks+elV+lpU51O1r1jDHRFYcJZELlfe8Z/WzaFTo4YS9Y0yUJv
+fRT2PEC5lDfSOPpDGTxtXmtdrE2c96LKnmWVJ2rHI9Of8HwYPIZCLUxIr5Ie/+3Y
+2VQVW7rsggoR3znu7bgdlwaQV/sGUFluca4rJ8f3aFNO2qGFt8NHRS9ddH5KfztJ
+L3wXksbWaKjdD99MougRNRahoqBPW0zs6WCMexqnLdJx6uEcAwDdeBOczsi4YUxl
+JJqH6MqTk37eloSXsvc36iJxlmUOX64djDTcBQKgO0PRJFRXUNuza/4UVshIIFFY
+UihFbE1iIRpx2NLEiB0JpnsH+k9mTSfniGH2oOUlEWB/SZJg/BtY8/Pbhrrf+Uga
+d9rA+wyY6VFPr+bUjcmfp4cXtXR9Zf5egDgqsc7SrsHHUqxPAz3pMx63RxxnBkIX
+kFL7HhE43gSq0X+hqgq9aJJp2wN7t+h7/ggt0D6clBS1HIm3EsVE3I2T2Em01PR2
+dQb4Mr5kFO5ovuKbn+RxNy4JjnjqUAKofieRoMopZMjeKNXyuH4EhCc1ZEFvbc29
+gFmWFEQtNzYSGP2SmpWqDvJ3k+hHkuMtXz+T/vMgMTlb7ZJtJUDNv+haEMyOTNbu
+8i0LpZo84PDtDaB1tpAvdyJCL+YMzAI2aYOtqG9Lk2EbotVAAj9MIfh6Ar7Fazxr
+uiWbBJpmjLsvfz4xPH7OIlm2S1Qa1KQ1DTiOJvK1f6EK9YqGl4sF3UMAcj+lBN30
+HkY6rQNpJ9aEyBNijeVCd6xrAqqsuqQAq1txrjcXtOJKaeKDTRlK1Q5RAMCppu9I
+CYIDB/HnYXlM0wKwf0xFAMuRMg1mVVYj3nILxNAlKEhRzeFZck+rmq4S0QJ73Ic/
+Zc1CZWcLg0LWnPYRdEtisb7x9tUPdriRWmcZtguzJulaag==
+=lfQi
 -----END PGP MESSAGE-----
 
---1dfecef114c8147d142d89d360f81b05--
+--5cbc4b0218c670f62c2d62f212ee0942--

test/test_mails/CanonicalFrom2.2BobToAlice_2_0.eml

@@ -1,66 +1,121 @@
-Message-ID: <pEp.QU52UD.1NRTPOIU8WPW5.52F885DE-7922-4DF4-95A3-06E4AC7EC458@pep-project.org>
+Message-ID: <pEp.QUA6IQ.1NK4BEPA0YUMS.3D7D71B9-60C3-4962-B212-CB41E1835FB5@pep-project.org>
 From: Bob Dog <pep.test.bob@pep-project.org>
 To: Alice Spivak Hyatt <pep.test.alice@pep-project.org>
 Subject: =?utf-8?Q?p=E2=89=A1p?=
 X-pEp-Version: 2.2
 MIME-Version: 1.0
-Content-Type: multipart/encrypted; boundary="23f474a847be193641d81def41840168"; 
+Content-Type: multipart/encrypted; boundary="2638d1b72ca02edd624e227015e5fc5d"; 
  protocol="application/pgp-encrypted"
 
---23f474a847be193641d81def41840168
+--2638d1b72ca02edd624e227015e5fc5d
 Content-Type: application/pgp-encrypted
 
 Version: 1
---23f474a847be193641d81def41840168
+--2638d1b72ca02edd624e227015e5fc5d
 Content-Type: application/octet-stream
 Content-Transfer-Encoding: 7bit
 Content-Disposition: inline; filename="msg.asc"
 
 -----BEGIN PGP MESSAGE-----
 
-wcBMA4rbkTfsG51OAQf+LPXIVFcv4fO/DboASdOE0ftdoG7ojNKGmJhsn3G8+RbM
-2NKppsSHwzySSt5ovgYf9Vaj8Vc/cAs5vg+iVqhBZ1NLpshkymM9ZxFHtkP0em3T
-S7Rz2a0lx3mpckHm23A4QNet0OUe7X9TTmVOf3/9ZReHTA+nhxIpQ36DF8/9ITLM
-kZo3YQ8COcPAgMJzyFiO+eCz3ZtFfJXEEUIRHINLBoFVW3930q1uHdDQee1iWA77
-XspkbV2EGU8O0IzUWXzEcZvfz+RLvrmXWJTtsh342vKiFHPEmx5PufOjSQ3brA4a
-MRtnnp+fzutfX7ranh0be7pJ/7t+eaBbNVWyz/w8XsHATANaAgXZcwg/TQEIALE3
-8u9OF6jRz83YJoGQ4L8QRLOA94jiqbVe+RpO++SDCPPjxasQDzaGJ86yzCs27bY4
-ly/ndyLynXlvjGddcAvGdhcazZerhxu+lW5AuEyTgcZ7V9XYrE45ij8x/D+jK+/c
-3dSCbwe6wbP8dsqpQCXwB+NBSaABluyDBXBok8nrifcYDEeieH3aXTjINTcDQvcd
-u8Pfw2KgaZbQJxLmUWZmMffme8IKJaZAG3GgMf/A06BXm8Nw5IRAiMfKGL/fLDov
-clipxAWQY2CYElfTgHgdo1SldDlJH8uBQVciYYNdbKNqicy61WhJkUNCiBIED79X
-GpnPH1ecR+PJvRK31ODSxPgBfEDPO+ajeTCFnC6QoohvAbEDLkgu7GgTuGFokjG3
-K10Z0SobIL9rMN1koqmWUQlovd2g8iuB6AYhX64wjz00j5rcWGY7xMcgcoO6J2HU
-7KEarvANhuDMTtfi8NshFsPrdQDQxiT1ckKuRfOTGYAQLMfugQmFXAV7ESBrIICe
-xwE4A/KUzWA+UM7YzEYTiJRMInBni6aaAlWYffc9y3JZk289orYhI0s5bO7lZ572
-9XlGCl2nUBPN4I+pF0fN674cFkJ9fudcZ02MckPR9hiFhjceltxdmDGKtiLqsdTP
-5Y2qI8Dj/qjxSCHFXvaBr5PhwHRzHda+xmVgFtxD4ArD5lafkg0Bq3dfk++K17Ct
-lJViMU+oEOymRZPQQmdAvHAeVByhp3D5HxWAL69ZyPNcaO8ie8OjqTujCS3BB0LK
-r3Un3kS5kNi+xyf4gqk5SCrcYeffcSqQvmcM+Ej54evgS31wy2EDYMEe+BmT0xnd
-XwoDs7q1nuoAJZkOxza0AKbooJvpv7zD/D82KHY4OBBZF00aLQ6iLbejja4W33Vu
-Fs5AVGjWXf83pIz0yb4hud1qNVgZe0evWdh5anA3T2PcgwxgBhqoQfq53hlpZACP
-cl96y8ePMGuMOEhNYvQywvfWD3VUsYrbh9UbdpBn7448pR4ZMWNXkZpiHwafrYAu
-M+ugNKg5sXGoc5omr7/mPbtncdpEw8efK1xSl9/16J5SnG3GWkShgzfb2/1g1e1a
-2dA8eEY/nq455nh7gZ2LgbNJaFUjFE3Rrs5Rws+nkrPnP/t8Q16ESoV1tWHmV728
-mAEe1ITpHmHeU+MoU+YsFSe95TIzaB2mpHtleQ8GPKU/aA+XIxcD1/8nCOuN0Au7
-KG68j54DslSy8174w3H/wHPEic+ToI//90prQPnDTU+/3eJ6rucIvy0WTGFNQBRk
-gbmAksfE4hXjLM8M579E/HjDpAG1SEqRT8DivNfwRvKpBUqEe7gfyoVfY3MEJD9R
-MkHLZO6hygxoaewf6s43gHUadxehPwMyWXtCu1225NUE0ZuJXiUQvnlaMKw2gH0m
-aYEhsrV7JomQH6SOZKazLmiuZy1Y8neYuXq5PYd187hNK9QYHHqpbI4peZ/NjkrH
-4kfevzkfSyfM42zuYTZcErF6OOeqrxR2nuOOjXUX6Q34L+IezDGDm3XWAhPXn1ug
-p5juOeag6ZxryIQbOR+hFNol7wJoF0ozmmiZVxT/zqzayMbs5PnyQuu4lTgaMeqO
-q8PCN9uf4zp7qPfr+DboWilzQIDjYeE02cClW7d2eFu9zpd79iDTYvRi5lxACAw3
-xRjQ3DYqDF9K2yT+uekZf2RrlKmlcP9YSg3HVdDwML6pGOMwaFMya1ReSK8P0MxU
-NBhFHzTu82+Q7iZT/J2euloAW+IxYabp7NaNmSe/Rca5qJkHR/N9bG7Qc0lnPDWK
-uZU7352jzqCUVt19Ck1tHROK4ZgyrsftffCtG+8JtuflL4cbmcplwTRC4YQG20Ox
-AifttJNbXL8hdNhq+HDQnv1PWvCOg+qLhKpIEljx6T8YoS5hywkXky8eRbTwI+lr
-Y1qEAjPSlWmfHqiA6yOUWJWkkWoJtWLfrXJi9Xmh5pzbugTPGaUZH48Djp5ZFT98
-EG8G1utoILodrnFM9D++pbB37ZsUPu2QS+3nFhmvD+kCRMMQ266AcGrG2smDO0hw
-dI6qq4ZXZ6J2kbJCiPGth1slANhapQFxN+crGB1auHgC0IPHHm/x4T397S8G8sRK
-GpOeJjmhTS5gsjE03yRBX1+OV5FgGUIVyMzw+C/q0IjrHdsCmD6nuDtYQPKv4toQ
-0bLy/J+pBnxcm7HHUJfzUMTd7dsIeMZ43apFW9pu6dasDx1Fzp9Oc3LaYoXJeobo
-SdhGSzqDoWJsjDrO8wXE2kjbzyFW1cRyh+GNH8J1Wfuds55tjrZW2m8=
-=50os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