Browse Source

ENGINE-633: default key import tests evolution

IPS-2
Krista Bennett 12 months ago
parent
commit
9f1324bf75
26 changed files with 2762 additions and 746 deletions
  1. +835
    -1
      test/src/DefaultFromEmailTest.cc
  2. +13
    -13
      test/src/GenerateMailsToMessageTypeTest.cc
  3. +7
    -4
      test/src/TestUtilities.cc
  4. +1
    -0
      test/src/TestUtilities.h
  5. +43
    -1
      test/test_mails/CanonicalFrom2.2BobToAliceUnencrypted.eml
  6. +90
    -32
      test/test_mails/CanonicalFrom2.2BobToAlice_1_0.eml
  7. +32
    -32
      test/test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey.eml
  8. +103
    -48
      test/test_mails/CanonicalFrom2.2BobToAlice_2_0.eml
  9. +48
    -48
      test/test_mails/CanonicalFrom2.2BobToAlice_2_0_NoKey.eml
  10. +161
    -54
      test/test_mails/CanonicalFrom2.2BobToAlice_2_1.eml
  11. +53
    -53
      test/test_mails/CanonicalFrom2.2BobToAlice_2_1_NoKey.eml
  12. +108
    -53
      test/test_mails/CanonicalFrom2.2BobToAlice_2_2.eml
  13. +71
    -0
      test/test_mails/CanonicalFrom2.2BobToAlice_2_2_NoKey.eml
  14. +90
    -32
      test/test_mails/CanonicalFrom2.2BobToAlice_OpenPGP.eml
  15. +50
    -0
      test/test_mails/CanonicalFrom2.2BobToAlice_OpenPGP_NoKey.eml
  16. +68
    -1
      test/test_mails/CanonicalFrom2.2SylviaToAliceUnencrypted.eml
  17. +142
    -43
      test/test_mails/CanonicalFrom2.2SylviaToAlice_1_0.eml
  18. +43
    -43
      test/test_mails/CanonicalFrom2.2SylviaToAlice_1_0_NoKey.eml
  19. +155
    -59
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_0.eml
  20. +59
    -59
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_0_NoKey.eml
  21. +64
    -64
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_1.eml
  22. +82
    -0
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_1_NoKey.eml
  23. +160
    -63
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_2.eml
  24. +81
    -0
      test/test_mails/CanonicalFrom2.2SylviaToAlice_2_2_NoKey.eml
  25. +142
    -43
      test/test_mails/CanonicalFrom2.2SylviaToAlice_OpenPGP.eml
  26. +61
    -0
      test/test_mails/CanonicalFrom2.2SylviaToAlice_OpenPGP_NoKey.eml

+ 835
- 1
test/src/DefaultFromEmailTest.cc View File

@ -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);
}

+ 13
- 13
test/src/GenerateMailsToMessageTypeTest.cc View File

@ -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;


+ 7
- 4
test/src/TestUtilities.cc View File

@ -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,


+ 1
- 0
test/src/TestUtilities.h View File

@ -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,


+ 43
- 1
test/test_mails/CanonicalFrom2.2BobToAliceUnencrypted.eml View File

@ -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"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--35090b856c4242f14c2f6ed5484850cf--

+ 90
- 32
test/test_mails/CanonicalFrom2.2BobToAlice_1_0.eml View File

@ -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--

+ 32
- 32
test/test_mails/CanonicalFrom2.2BobToAlice_1_0_NoKey.eml View File

@ -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--

+ 103
- 48
test/test_mails/CanonicalFrom2.2BobToAlice_2_0.eml View File

@ -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-----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=50os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=Wy1z
-----END PGP MESSAGE-----
--23f474a847be193641d81def41840168--
--2638d1b72ca02edd624e227015e5fc5d--

+ 48
- 48
test/test_mails/CanonicalFrom2.2BobToAlice_2_0_NoKey.eml View File

@ -1,66 +1,66 @@
Message-ID: <pEp.QU5057.182A4YAQUC7WP.C42C211C-1065-49E4-B977-5176AFD14AD9@pep-project.org>
Message-ID: <pEp.QUA6J4.1PKBU979MWU34.F497D944-12AE-4DD8-AE4E-A1737310F0BA@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="3d1ed8b573fcb981ff748e753a3e3a8";
Content-Type: multipart/encrypted; boundary="888fd1c45444524d26be20a2656fd";
protocol="application/pgp-encrypted"
--3d1ed8b573fcb981ff748e753a3e3a8
--888fd1c45444524d26be20a2656fd
Content-Type: application/pgp-encrypted
Version: 1
--3d1ed8b573fcb981ff748e753a3e3a8
--888fd1c45444524d26be20a2656fd
Content-Type: application/octet-stream
Content-Transfer-Encoding: 7bit
Content-Disposition: inline; filename="msg.asc"
-----BEGIN PGP MESSAGE-----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=LjLf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=V0gj
-----END PGP MESSAGE-----
--3d1ed8b573fcb981ff748e753a3e3a8--
--888fd1c45444524d26be20a2656fd--

+ 161
- 54
test/test_mails/CanonicalFrom2.2BobToAlice_2_1.eml View File

@ -1,71 +1,178 @@
Message-ID: <pEp.QU52UF.0JSDITSGYK5V0.5FCBBC71-16B9-4571-8CCF-7F0A4B469EAE@pep-project.org>
From: Bob Dog <pep.test.bob@pep-project.org>
Message-ID: <pEp.QUA6IU.1DWPAPA5IZTUO.1CDEE215-DFA2-4765-9E5D-C0A34FC0D2E6@darthmama.org>
From: Sylvia Plath <sylvia@darthmama.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="f78767d70252dee789d38c452db88d8";
Content-Type: multipart/encrypted; boundary="27d7d074c1651a34f881c2b503cb860";
protocol="application/pgp-encrypted"
--f78767d70252dee789d38c452db88d8