diff --git a/enzevalos_iphone/DataHandler.swift b/enzevalos_iphone/DataHandler.swift
index 1d3573dc682b768cc4ce3c4b0e829412d5b17064..3ef27222e33bf82fe30bd59b51b064d1bec5a640 100644
--- a/enzevalos_iphone/DataHandler.swift
+++ b/enzevalos_iphone/DataHandler.swift
@@ -77,20 +77,7 @@ class DataHandler {
- func hasMail(folderName: String, uid: UInt64) -> Bool {
- let folder = findFolder(with: folderName)
- // TODO: As Sql rquest with NSPredicate?
- if let mails = folder.mails {
- for m in mails {
- let mail = m as! PersistentMail
- if mail.uid == uid {
- return true
- }
- }
- }
- return false
- }
-
+
func callForFolders(done: @escaping ((_ error: Error?) -> ())) { // Maybe call back? Look for new Folder?
AppDelegate.getAppDelegate().mailHandler.allFolders { (err, array) -> Void in
@@ -296,9 +283,9 @@ class DataHandler {
func reset() {
removeAll(entity: "PersistentMail")
removeAll(entity: "Folder")
+ removeAll(entity: "EnzevalosContact")
removeAll(entity: "SecretKey")
removeAll(entity: "PersistentKey")
- removeAll(entity: "EnzevalosContact")
removeAll(entity: "Mail_Address")
save(during: "reset")
}
@@ -471,7 +458,7 @@ class DataHandler {
private func find(_ entityName: String, type: String, search: String) -> [AnyObject]? {
let fReq: NSFetchRequest = NSFetchRequest<NSFetchRequestResult>(entityName: entityName)
- fReq.predicate = NSPredicate(format: "\(type) CONTAINS %@ ", search) //FIXME: Was ist hier mit Injections? Vorsicht wo das verwendet wird! Nicht, dass hier UI Eingaben reinkommen können...
+ fReq.predicate = NSPredicate(format: "\(type) CONTAINS %@ ", search)
let result: [AnyObject]?
do {
result = try self.managedObjectContext.fetch(fReq)
diff --git a/enzevalos_iphone/enzevalos_iphone.xcdatamodeld/enzevalos_iphone.xcdatamodel/contents b/enzevalos_iphone/enzevalos_iphone.xcdatamodeld/enzevalos_iphone.xcdatamodel/contents
index 323ec496d227db3571ba16811878ea9fe186fe61..de8337dce570d0bdf775d6a44e6aacead3c1a592 100644
--- a/enzevalos_iphone/enzevalos_iphone.xcdatamodeld/enzevalos_iphone.xcdatamodel/contents
+++ b/enzevalos_iphone/enzevalos_iphone.xcdatamodeld/enzevalos_iphone.xcdatamodel/contents
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<model type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="13772" systemVersion="17D47" minimumToolsVersion="Automatic" sourceLanguage="Swift" userDefinedModelVersionIdentifier="">
+<model type="com.apple.IDECoreDataModeler.DataModel" documentVersion="1.0" lastSavedToolsVersion="13772" systemVersion="16G1212" minimumToolsVersion="Automatic" sourceLanguage="Swift" userDefinedModelVersionIdentifier="">
<entity name="Account" representedClassName="Account" syncable="YES" codeGenerationType="class">
<attribute name="archiveFolderPath" attributeType="String" syncable="YES"/>
<attribute name="displayName" attributeType="String" syncable="YES"/>
@@ -33,8 +33,8 @@
<attribute name="cnidentifier" optional="YES" attributeType="String" syncable="YES"/>
<attribute name="color" optional="YES" attributeType="Transformable" customClassName="UIColor" syncable="YES"/>
<attribute name="displayname" attributeType="String" syncable="YES"/>
- <relationship name="addresses" toMany="YES" deletionRule="Nullify" destinationEntity="Mail_Address" inverseName="contact" inverseEntity="Mail_Address" syncable="YES"/>
- <relationship name="keyrecords" optional="YES" toMany="YES" deletionRule="Nullify" destinationEntity="KeyRecord" inverseName="contact" inverseEntity="KeyRecord" syncable="YES"/>
+ <relationship name="addresses" toMany="YES" deletionRule="Cascade" destinationEntity="Mail_Address" inverseName="contact" inverseEntity="Mail_Address" syncable="YES"/>
+ <relationship name="keyrecords" optional="YES" toMany="YES" deletionRule="Cascade" destinationEntity="KeyRecord" inverseName="contact" inverseEntity="KeyRecord" syncable="YES"/>
</entity>
<entity name="Folder" representedClassName="Folder" syncable="YES">
<attribute name="delimiter" optional="YES" attributeType="String" syncable="YES"/>
@@ -148,11 +148,11 @@
<element name="Attachment" positionX="-315" positionY="-36" width="128" height="210"/>
<element name="EnzevalosContact" positionX="-209" positionY="198" width="128" height="120"/>
<element name="Folder" positionX="-297" positionY="-18" width="128" height="225"/>
+ <element name="KeyRecord" positionX="-315" positionY="-36" width="128" height="105"/>
<element name="Mail_Address" positionX="-297" positionY="-18" width="128" height="210"/>
<element name="PersistentKey" positionX="-315" positionY="-36" width="128" height="270"/>
<element name="PersistentMail" positionX="-416" positionY="-189" width="128" height="540"/>
- <element name="KeyRecord" positionX="-315" positionY="-36" width="128" height="105"/>
<element name="SecretKey" positionX="-306" positionY="-27" width="128" height="135"/>
<element name="Server" positionX="-306" positionY="-27" width="128" height="135"/>
</elements>
-</model>
+</model>
\ No newline at end of file
diff --git a/enzevalos_iphoneTests/CoreDataTests.swift b/enzevalos_iphoneTests/CoreDataTests.swift
index c75ef0e571f0e89335f9e391aa42029a3be22f7c..676e9f683e022a812350b057cc6d5c5dd95ce505 100644
--- a/enzevalos_iphoneTests/CoreDataTests.swift
+++ b/enzevalos_iphoneTests/CoreDataTests.swift
@@ -5,712 +5,291 @@
// Created by Oliver Wiese on 30.01.18.
// Copyright © 2018 fu-berlin. All rights reserved.
//
-
import XCTest
+/*
+ Testcases:
+ One plain mail, one encrypted mail
+ multiple plain mails form one adr, multiple encryted mails from one adr, multiple enc + plain mails from one adr
+ plain mails from different adr, enc mails from different adr, enc+plain mails from different adr
+ One EnzContact with multi adr/keys
+ One adr with different keys
+
+ Own ID
+
+ Overview Enzcontacts, adr
+ Test Inbox
+ - #records
+ - #Sortierung, #Mails
+ Test EnzContact
+ - #records
+
+ */
+
@testable import enzevalos_iphone
class CoraDataTests: XCTestCase {
let datahandler = DataHandler.handler
let pgp = SwiftPGP()
-
+
let userAdr = "alice@example.com"
let userName = "alice"
var user: MCOAddress = MCOAddress.init(mailbox: "alice@example.com")
var userKeyID: String = ""
-
+
override func setUp() {
+ super.setUp()
datahandler.reset()
+ pgp.resetKeychains()
+ XCTAssertEqual(datahandler.findSecretKeys().count, 0)
+ XCTAssertEqual(datahandler.allFolders.count, 0)
+ XCTAssertEqual(datahandler.getContacts().count, 0)
+ XCTAssertEqual(datahandler.getAddresses().count, 0)
(user, userKeyID) = owner()
}
override func tearDown() {
datahandler.reset()
+ pgp.resetKeychains()
+ super.tearDown()
}
- /*
- Testcases:
- One plain mail, one encrypted mail
- multiple plain mails form one adr, multiple encryted mails from one adr, multiple enc + plain mails from one adr
- plain mails from different adr, enc mails from different adr, enc+plain mails from different adr
- One EnzContact with multi adr/keys
- One adr with different keys
-
- Own ID
-
- Overview Enzcontacts, adr
- Test Inbox
- - #records
- - #Sortierung, #Mails
- Test EnzContact
- - #records
-
- test getMethods. ala: getContact, get MailAddr etc
-
- */
- func testFirstPlainMail(){
- datahandler.reset()
- let senderAdr = "bob@example.com"
- let sender = MCOAddress.init(displayName: "Bob", mailbox: senderAdr)
- let receiverAdr = userAdr
- let receiver = MCOAddress.init(displayName: userName, mailbox: receiverAdr)
- let flags = MCOMessageFlag.answered
- let folder = "folder"
-
- XCTAssertNil(datahandler.findMailAddress(adr: senderAdr))
- //XCTAssertNil(datahandler.findMailAddress(adr: receiverAdr))
- XCTAssertTrue(datahandler.allFolders.count <= 1)
- let preMails = datahandler.allMailsInFolder(key: nil, contact: nil, folder: nil, isSecure: false)
- XCTAssertTrue(preMails.count == 0)
-
- let mail = testMail(from: sender!, to: [receiver!], cc: [], bcc: [], flags: flags, folder: folder)
- XCTAssertEqual(datahandler.findFolder(with: folder).counterMails,1)
- XCTAssertNotNil(mail)
-
-
- XCTAssertNotNil(datahandler.findMailAddress(adr: receiverAdr))
- if let mailAdr = datahandler.findMailAddress(adr: receiverAdr){
- let receiverContact = datahandler.getContactByAddress(receiverAdr)
- testEnzContact(enzContact: receiverContact, addresses: [mailAdr], from: [], to: [mail!], cc: [], bcc: [], keys: [])
- testMailAdr(mailAdr: mailAdr, hasKey: false, adr: receiverAdr, ezContact: receiverContact, primaryKey: nil, keys: [])
- }
-
- XCTAssertNotNil(datahandler.findMailAddress(adr: senderAdr))
- if let mailAdr = datahandler.findMailAddress(adr: senderAdr){
- let senderContact = datahandler.getContactByAddress(senderAdr)
- testEnzContact(enzContact: senderContact, addresses: [mailAdr], from: [mail!], to: [], cc: [], bcc: [], keys: [])
- testMailAdr(mailAdr:mailAdr, hasKey: false, adr: senderAdr, ezContact: senderContact, primaryKey: nil, keys: [])
- }
- }
-
-
-
-
- func testMultiplePlainMails(){
- datahandler.reset()
- let (user, id) = createPGPUser()
- let sender = createUser()
- let mails = sendMails(sender: sender, user: user, userID: id)
-
- XCTAssertNotNil(datahandler.findMailAddress(adr: user.mailbox))
- if let mailAdr = datahandler.findMailAddress(adr: user.mailbox){
- let receiverContact = datahandler.getContactByAddress(user.mailbox)
- testEnzContact(enzContact: receiverContact, addresses: [mailAdr], from: [], to: mails, cc: [], bcc: [], keys: [])
- testMailAdr(mailAdr: mailAdr, hasKey: false, adr: user.mailbox, ezContact: receiverContact, primaryKey: nil, keys: [])
- }
+ func createUser(adr: String = String.random().lowercased(), name: String = String.random()) -> MCOAddress{
+ return MCOAddress.init(displayName: name, mailbox: adr.lowercased())
}
- func testMultiEncMails(){
- sendMultiEncMails(sameFolder: false)
+ func createPGPUser(adr: String = String.random().lowercased(), name: String = String.random()) -> (MCOAddress, String){
+ let user = createUser(adr: adr, name: name)
+ let id = pgp.generateKey(adr: user.mailbox)
+ return (user, id)
}
- func testSimpleFolderRecords(){
- sendMultiEncMails(sameFolder: true)
+ func owner() -> (MCOAddress, String){
+ Logger.logging = false
+ let (user, userid) = createPGPUser(adr: userAdr, name: userName)
+ UserManager.storeUserValue(userAdr as AnyObject, attribute: Attribute.userAddr)
+ UserManager.storeUserValue(userid as AnyObject, attribute: Attribute.prefSecretKeyID)
+ return (user, userid)
}
- func sendMultiEncMails(sameFolder: Bool){
- datahandler.reset()
- let senders = createSender(n: 2)
- let (user, userid) = owner()
+ func testArrivingMail(){
+ let sender = createUser()
+ let folder = "INBOX"
+ XCTAssertNil(datahandler.findMailAddress(adr: sender.mailbox))
- let folder = String.random()
- var allMails = [MCOAddress:Set<PersistentMail>] ()
-
- for (sender, id) in senders{
- if sameFolder{
- allMails[sender] = sendMails(sender: sender, user: user, userID: userid, numberOfMails: 10, folder: folder)
- let (ms, key) = sendEncMails(sender: sender, senderID: id, user: user, userID: userid, prevMails: allMails[sender]!, folder: folder)
- allMails[sender] = allMails[sender]?.union(ms)
- for mail in ms{
- XCTAssertEqual(mail.folder.name, folder)
- }
- let mails = sendMails(sender: sender, user: user, userID: id, numberOfMails: 10, hasKey: true, primaryKey: key!, keys: [key!], previousMails: allMails[sender]!, folder: folder)
- allMails[sender] = allMails[sender]?.union(mails)
-
- }
- else{
- allMails[sender] = sendMails(sender: sender, user: user, userID: userid, numberOfMails: 10)
- let (ms, key) = sendEncMails(sender: sender, senderID: id, user: user, userID: userid, prevMails: allMails[sender]!)
- allMails[sender] = allMails[sender]?.union(ms)
- let mails = sendMails(sender: sender, user: user, userID: id, numberOfMails: 10, hasKey: true, primaryKey: key!, keys: [key!], previousMails: allMails[sender]!)
- allMails[sender] = allMails[sender]?.union(mails)
- }
- }
- if sameFolder{
+ if let mail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folder){
+ XCTAssertFalse(mail.isSecure)
+ XCTAssertFalse(mail.isEncrypted)
+ XCTAssertFalse(mail.isSigned)
+ XCTAssertFalse(mail.trouble)
+ XCTAssertFalse(mail.isCorrectlySigned)
+
+ XCTAssertNotNil(datahandler.findMailAddress(adr: sender.mailbox))
let f = datahandler.findFolder(with: folder)
- for (sender, id) in senders{
- let mykey = datahandler.findKey(keyID: id)
- for mail in allMails[sender]!{
- XCTAssertEqual(mail.folder.name, folder)
- XCTAssertEqual(mail.folder, f)
- if mail.folder != f{
- print("Not in folder!")
- XCTAssert(false)
- }
- if let mailKey = mail.signedKey{
- XCTAssertEqual(mail.keyID, mykey?.keyID)
- XCTAssertEqual(mail.keyID, id)
- XCTAssertEqual(mail.keyID, mailKey.keyID)
-
- }
- XCTAssertEqual(mail.from.mailAddress, sender.mailbox)
+ XCTAssertEqual(f.mailsOfFolder.count, 1)
+ XCTAssertEqual(f.records.count, 1)
+ var containsMail = false
+ for m in f.mailsOfFolder{
+ if m == mail{
+ containsMail = true
}
}
-
- //TODO: check keys in folder (siehe datanhandler)
- let folderKeys = datahandler.allKeysInFolder(folder: f)
- XCTAssertEqual(folderKeys.count, senders.count)
-
- print("My keys in folder: \(folderKeys.count)")
- XCTAssertEqual(f.records.count, senders.count * 2)
- print(f.records.count)
+ XCTAssertTrue(containsMail)
+ var containsAddr = false
for r in f.records{
- print(r.mails.count)
- print(r.addresses.count)
- }
- for mails in allMails.values{
- for mail in mails{
- if mail.folder.name != folder{
- print("ERROR!!!")
+ for a in r.addresses{
+ if a.mailAddress == sender.mailbox {
+ containsAddr = true
}
- XCTAssertEqual(mail.folder.name, folder)
}
}
+ XCTAssertTrue(containsAddr)
}
+ else {
+ XCTFail("No mail")
+ }
+ //TODO: May test cc, bbcc fields
}
- func testKeyRecords(){
-
+ func testMultiplePlainMailsFromOne() {
+ let sender = createUser()
+ let n = 100
let folderName = "INBOX"
- let folder = datahandler.findFolder(with: folderName)
- XCTAssertEqual(folder.records.count, 0)
-
- var mails = Set<PersistentMail>()
-
- let a = createUser()
- let b = createUser()
- let c = createUser()
- // Eine unverschlüsselte E-Mail von A kommt an -> Neuer Record wird angelegt
- var newMails = self.sendMails(sender: a, user: user, userID: userKeyID, numberOfMails: 1, hasKey: false, primaryKey: nil, keys: [], previousMails: mails, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
+ XCTAssertNil(datahandler.findMailAddress(adr: sender.mailbox))
+ for _ in 1...n {
+ _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName)
}
+ let folder = datahandler.findFolder(with: folderName)
XCTAssertEqual(folder.records.count, 1)
- // Eine unverschlüsselte Email kommt von B an -> Neuer Record und B vor A
- newMails = self.sendMails(sender: b, user: user, userID: userKeyID, numberOfMails: 1, hasKey: false, primaryKey: nil, keys: [], previousMails: mails, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 2)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, b.mailbox)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, a.mailbox)
- // Eine unverschlüsselte E-Mail von A kommt an -> A vor B
- newMails = sendMails(sender: a, user: user, userID: userKeyID, numberOfMails: 1, hasKey: false, primaryKey: nil, keys: [], previousMails: mails, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 2)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, a.mailbox)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, b.mailbox)
- // eine unverschlüsselte E-Mail von C kommt an -> C, A, B
- newMails = sendMails(sender: c, user: user, userID: userKeyID, numberOfMails: 1, hasKey: false, primaryKey: nil, keys: [], previousMails: mails, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 3)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, c.mailbox)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, a.mailbox)
- XCTAssertEqual(folder.records[2].addresses[0].mailAddress, b.mailbox)
- // eine verschlüsselte Nachricht von B kommt an -> Neuer Record B1 vor C, A vor B
- let (b1, bID1) = createPGPUser(adr: b.mailbox, name: b.displayName)
- var newKey: PersistentKey?
- (newMails, newKey) = sendEncMails(sender: b1, senderID: bID1, user: user, userID: userKeyID, prevMails: mails, keys: [], primKey: nil, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 4)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, b1.mailbox)
- XCTAssertEqual(folder.records[0].isSecure, true)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, c.mailbox)
- XCTAssertEqual(folder.records[2].addresses[0].mailAddress, a.mailbox)
- XCTAssertEqual(folder.records[3].addresses[0].mailAddress, b.mailbox)
- XCTAssertEqual(folder.records[3].isSecure, false)
- // Unverschlüsselte Email von A -> A, B1, C, B
- newMails = sendMails(sender: a, user: user, userID: userKeyID, numberOfMails: 1, hasKey: true, primaryKey: newKey, keys: [newKey!], previousMails: mails, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 4)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, a.mailbox)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, b1.mailbox)
- XCTAssertEqual(folder.records[1].isSecure, true)
- XCTAssertEqual(folder.records[2].addresses[0].mailAddress, c.mailbox)
- XCTAssertEqual(folder.records[3].addresses[0].mailAddress, b.mailbox)
- XCTAssertEqual(folder.records[3].isSecure, false)
- // eine neu verschlüsselte Nachricht mit neuem Key von B -> B2, A, A, B', B
- let (b2, bID2) = createPGPUser(adr: b.mailbox, name: b.displayName)
- (newMails, newKey) = sendEncMails(sender: b2, senderID: bID2, user: user, userID: userKeyID, prevMails: mails, keys: [], primKey: nil, folder: folderName)
- mails = mails.union(newMails)
- for m in newMails{
- folder.updateRecords(mail: m)
- }
- XCTAssertEqual(folder.records.count, 5)
- XCTAssertEqual(folder.records[0].addresses[0].mailAddress, b2.mailbox)
- XCTAssertEqual(folder.records[0].isSecure, true)
- XCTAssertEqual(folder.records[0].keyID, bID2)
- XCTAssertEqual(folder.records[1].addresses[0].mailAddress, a.mailbox)
- XCTAssertEqual(folder.records[2].addresses[0].mailAddress, b1.mailbox)
- XCTAssertEqual(folder.records[2].isSecure, true)
- XCTAssertEqual(folder.records[2].keyID, bID1)
- XCTAssertEqual(folder.records[3].addresses[0].mailAddress, c.mailbox)
- XCTAssertEqual(folder.records[4].addresses[0].mailAddress, b.mailbox)
- XCTAssertEqual(folder.records[4].isSecure, false)
- }
-
- func testOwnRecord(){
- // teste, ob alle eigenen Keys da sind
-
- // teste, ob das hin und herspringen klappt.
+ XCTAssertEqual(folder.mailsOfFolder.count, n)
+ XCTAssertTrue(checkOrderingOfRecord(record: folder.records.first!))
}
-
- func testMultiKeys(){
- datahandler.reset()
- let sender = createPGPUser()
- let user = owner()
- let n = 1 // number of keys
-
- var allMails = Set<PersistentMail>()
- var keys = Set<PersistentKey>()
- var lastKey: PersistentKey?
- var primKey: PersistentKey?
- var newMails = Set<PersistentMail>()
-
- let folder = String.random()
-
- allMails = sendMails(sender: sender.0, user: user.0, userID: user.1, folder: folder)
- (newMails, lastKey) = sendEncMails(sender: sender.0, senderID: sender.1, user: user.0, userID: user.1, prevMails: allMails, folder: folder)
- allMails = newMails.union(allMails)
- primKey = lastKey
- if let key = lastKey{
- keys.insert(key)
- }
- for _ in 1...n{
- let sender2 = createPGPUser(adr: sender.0.mailbox, name: sender.0.displayName)
- newMails = sendMails(sender: sender.0, user: user.0, userID: user.1, hasKey: true, primaryKey: primKey, keys: Array(keys),previousMails: allMails, folder: folder)
- allMails = newMails.union(allMails)
- (newMails, lastKey) = sendEncMails(sender: sender2.0, senderID: sender2.1, user: user.0, userID: user.1, prevMails: allMails, keys: keys, folder : folder)
- allMails = newMails.union(allMails)
- primKey = lastKey
- if let key = lastKey{
- keys.insert(key)
+ func testMultiplePlainMails() {
+ let n = 10
+ let m = 10
+ let folderName = "INBOX"
+ for _ in 1...n {
+ let sender = createUser()
+ for _ in 1...m {
+ _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName)
}
}
- // Test contact with focus on multiple pks
- let enzContact = datahandler.getContactByAddress(sender.0.mailbox)
- let mailAdr = datahandler.getMailAddress(sender.0.mailbox, temporary: false)
-
- XCTAssertEqual(enzContact.publicKeys.count, keys.count)
- testEnzContact(enzContact: enzContact, addresses: [mailAdr], from: allMails, to: [], cc: [], bcc: [], keys: Array(keys))
- for key in keys{
- let keyContact = datahandler.getContact(keyID: key.keyID)
- XCTAssertEqual(keyContact, enzContact)
- }
- // Test mail adr with focus on multiple pks and prim key
- XCTAssertEqual(mailAdr.publicKeys.count, keys.count)
- XCTAssertEqual(mailAdr.primaryKey?.keyID, primKey?.keyID)
- testMailAdr(mailAdr: mailAdr as! Mail_Address, hasKey: true, adr: sender.0.mailbox, ezContact: enzContact, primaryKey: primKey, keys: Array(keys))
- // Test key records -> folders?
- for m in allMails{
- XCTAssertEqual(m.folder.name, folder)
- }
- let f = datahandler.findFolder(with: folder)
- let records = datahandler.folderRecords(folderPath: folder)
- XCTAssertEqual(records.count, keys.count + 1)
- XCTAssertEqual(f.records.count, keys.count + 1)
- var counterInsecureRecords = 0
- var countMails = 0
- for record in f.records{
- if record.isSecure{
- var found = false
- for key in keys{
- if key.keyID == record.keyID{
- found = true
- break
- }
- }
- XCTAssertTrue(found)
- }
- else{
- counterInsecureRecords = counterInsecureRecords + 1
+ let folder = datahandler.findFolder(with: folderName)
+ XCTAssertEqual(folder.records.count, n)
+ var prev: KeyRecord?
+ for record in folder.records {
+ XCTAssertEqual(record.mails.count, m)
+ XCTAssertTrue(checkOrderingOfRecord(record: record))
+ if let prev = prev {
+ XCTAssertTrue(prev < record)
}
- countMails = countMails + record.mails.count
-
+ prev = record
}
- XCTAssertEqual(counterInsecureRecords, 1)
- XCTAssertEqual(countMails, allMails.count)
}
- func sendMails(sender: MCOAddress, user: MCOAddress, userID: String, numberOfMails: Int = 10, hasKey: Bool = false, primaryKey: PersistentKey? = nil , keys: [PersistentKey] = [], previousMails: Set<PersistentMail> = Set<PersistentMail>(), folder: String = String.random()) -> Set<PersistentMail>{
- var mails = Set<PersistentMail>()
-
- for _ in 1...numberOfMails{
- let flag = MCOMessageFlag.answered
- if let mail = testMail(from: sender, to: [user], cc: [], bcc: [], flags: flag, folder: folder){
- mails.insert(mail)
- }
-
- }
- var mailCounter = numberOfMails
- for m in previousMails{
- if m.folder.name == folder{
- mailCounter = mailCounter + 1
+ func testMixedMails() {
+ let (sender, keyID) = createPGPUser()
+ let n = 10
+ let senderPGP = SwiftPGP()
+ let body = "mixed mails"
+ let folderName = "INBOX"
+ for _ in 1...n {
+ let cryptoObject = senderPGP.encrypt(plaintext: body , ids: [userKeyID], myId: keyID)
+ if let encMail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject),
+ let plainMail = testMail(from: sender, to: [user], cc: [], bcc: []) {
+ XCTAssertTrue(encMail.isSecure && encMail.isSigned && encMail.isCorrectlySigned && encMail.isEncrypted && encMail.signedKey?.keyID == keyID)
+ XCTAssertTrue(encMail.body == body)
+ XCTAssertTrue(encMail.from.mailAddress == plainMail.from.mailAddress && encMail.from.primaryKey?.keyID == plainMail.from.primaryKey?.keyID)
+ XCTAssertTrue(plainMail.from.hasKey)
+ } else {
+ XCTFail("No mails")
}
}
- // XCTAssertEqual(datahandler.findFolder(with: folder).counterMails, mailCounter)
- XCTAssertNotNil(datahandler.findMailAddress(adr: (sender.mailbox)!))
- if let mailAdr = datahandler.findMailAddress(adr: (sender.mailbox)!){
- let allMails = previousMails.union(mails)
- let senderContact = datahandler.getContactByAddress((sender.mailbox)!)
- // testEnzContact(enzContact: senderContact, addresses: [mailAdr], from: allMails, to: [], cc: [], bcc: [], keys:keys)
- testMailAdr(mailAdr:mailAdr, hasKey: hasKey, adr: (sender.mailbox)!, ezContact: senderContact, primaryKey: primaryKey, keys: keys)
- }
- return mails
- }
-
- func sendEncMails(sender: MCOAddress, senderID: String, user: MCOAddress, userID: String, prevMails: Set<PersistentMail>, keys: Set<PersistentKey> = Set<PersistentKey>(), primKey: PersistentKey? = nil, folder: String = String.random()) -> (Set<PersistentMail>, PersistentKey?){
- var mails = Set<PersistentMail>()
- var key: PersistentKey?
- var primaryKey: PersistentKey?
- var firstmail: PersistentMail?
- var mykeys = keys
- if let k = primKey{
- primaryKey = k
- }
-
- for _ in 1...10{
- let message = String.random(length: 10)
- let chipher = pgp.encrypt(plaintext: message, ids: [userID], myId: senderID)
-
- let plain = pgp.decrypt(data: chipher.chiphertext!, decryptionId: userID, verifyIds: [senderID], fromAdr: sender.mailbox)
- if let mail = testMail(from: sender, to: [user], cc: [], bcc: [], flags: MCOMessageFlag.answered, folder: folder, date: Date(), cryptoObject: plain, isSecure: true, message: message){
- let k = datahandler.newPublicKey(keyID: senderID, cryptoType: .PGP, adr: sender.mailbox, autocrypt: false, firstMail: mail, newGenerated: false)
- if key == nil{
- key = k
- firstmail = mail
- primaryKey = k
- mykeys.insert(k)
- }
- let k2 = datahandler.findKey(keyID: k.keyID)
- let f = datahandler.findFolder(with: folder)
- for m in f.mails!{
- if let mail = m as? PersistentMail{
- if mail.keyID == k2?.keyID{
- print("k in mail in folder!")
- }
- }
- }
- let keys = datahandler.allKeysInFolder(folder: f)
- for myKey in keys{
- if myKey == k2?.keyID{
- print("k in keys of folder! \(myKey)")
- }
- }
- mails.insert(mail)
+ let folder = datahandler.findFolder(with: folderName)
+ XCTAssertEqual(folder.records.count, 2)
+ var secureRecord = false
+ var insecureRecord = false
+ for record in folder.records {
+ XCTAssertEqual(record.mails.count, n)
+ if record.isSecure {
+ secureRecord = true
+ XCTAssertTrue(record.keyID == keyID)
}
- }
- let enzContact = datahandler.getContactByAddress(sender.mailbox)
- key = datahandler.findKey(keyID: senderID)
- XCTAssertNotNil(key?.mailaddress)
- if let addrs = key?.mailaddress{
- XCTAssertEqual(addrs.count, 1)
- for a in addrs{
- if let addr = a as? Mail_Address{
- XCTAssertEqual(addr.address, sender.mailbox)
- XCTAssertEqual(addr.primaryKey?.keyID, primaryKey?.keyID)
- XCTAssertEqual(addr.primaryKey?.firstMail?.subject, firstmail?.subject)
- }
+ else {
+ insecureRecord = true
}
}
- let allMails = prevMails.union(mails)
- XCTAssertEqual(enzContact, datahandler.getContact(keyID: senderID))
- //XCTAssertEqual(enzContact.from.count, allMails.count)
-
- let records = enzContact.records
- XCTAssertEqual(records.count, mykeys.count + 1)
-
-
- return (mails, key)
- }
- // Testen: #Mails, Zuordnung zu sicherem Kontakt. In einem Keyrecord? #Keyrecords pro Kontakt.
-
- func createUser(adr: String = String.random().lowercased(), name: String = String.random()) -> MCOAddress{
- return MCOAddress.init(displayName: name, mailbox: adr.lowercased())
- }
-
- func createPGPUser(adr: String = String.random().lowercased(), name: String = String.random()) -> (MCOAddress, String){
- let user = createUser(adr: adr, name: name)
- let id = pgp.generateKey(adr: user.mailbox)
- return (user, id)
- }
-
- func owner() -> (MCOAddress, String){
- Logger.logging = false
- let (user, userid) = createPGPUser(adr: userAdr, name: userName)
- UserManager.storeUserValue(userAdr as AnyObject, attribute: Attribute.userAddr)
- UserManager.storeUserValue(userid as AnyObject, attribute: Attribute.prefSecretKeyID)
- return (user, userid)
+ XCTAssertTrue(secureRecord)
+ XCTAssertTrue(insecureRecord)
}
- func createSender(n: Int)-> [MCOAddress:String]{
- var result = [MCOAddress:String]()
+ func testNewKey() {
+ let (sender, keyID1) = createPGPUser()
+ let senderPGP = SwiftPGP()
+ let body = "mixed mails"
+ let folderName = "INBOX"
- for _ in 1...n{
- let adr = String.random()
- let name = String.random()
-
- let (mcoaddr, id) = createPGPUser(adr: adr, name: name)
- result[mcoaddr] = id
- }
- return result
- }
-
-
-
-
-
-
- func testMail(from: MCOAddress, to: [MCOAddress], cc: [MCOAddress], bcc: [MCOAddress], flags: MCOMessageFlag, folder: String , date: Date = Date(), cryptoObject: CryptoObject? = nil, isSecure: Bool = false, message: String? = nil) -> PersistentMail?{
- let subject = String.random(length: 20)
- var body = String.random(length: 20)
+ let cryptoObject1 = senderPGP.encrypt(plaintext: body , ids: [userKeyID], myId: keyID1)
+ _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject1)
- if let m = message{
- body = m
- }
- let id = UInt64(arc4random())
- var preMails = Set<PersistentMail>()
- var ms = datahandler.allMailsInFolder(key: nil, contact: nil, folder: nil, isSecure: false)
- preMails = preMails.union(ms)
- ms = datahandler.allMailsInFolder(key: nil, contact: nil, folder: nil, isSecure: true)
- preMails = preMails.union(ms)
+ let keyID2 = pgp.generateKey(adr: sender.mailbox)
+ let cryptoObject2 = senderPGP.encrypt(plaintext: body , ids: [userKeyID], myId: keyID2)
+ _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject2)
- var mail: PersistentMail?
-
- if cryptoObject != nil{
- mail = datahandler.createMail(id, sender: from, receivers: to, cc: cc, time: date, received: true, subject: subject, body: nil, flags: flags, record: nil, autocrypt: nil, decryptedData: cryptoObject, folderPath: folder, secretKey: nil)
- }
- else{
- mail = datahandler.createMail(id, sender: from, receivers: to, cc:cc, time: date, received: true, subject: subject, body: body, flags: flags, record: nil, autocrypt: nil, decryptedData: nil, folderPath: folder, secretKey: nil)
- }
- XCTAssertNotNil(mail)
- let f = datahandler.findFolder(with: folder)
- if let m = mail{
- f.updateRecords(mail: m)
+ let folder = datahandler.findFolder(with: folderName)
+ XCTAssertEqual(folder.records.count, 2)
+ for record in folder.records {
+ XCTAssertTrue(record.isSecure)
+ XCTAssertTrue(record.keyID == keyID1 || record.keyID == keyID2)
}
- var allMails = Set<PersistentMail>()
- ms = datahandler.allMailsInFolder(key: nil, contact: nil, folder: nil, isSecure: false)
- allMails = allMails.union(ms)
- ms = datahandler.allMailsInFolder(key: nil, contact: nil, folder: nil, isSecure: true)
- allMails = allMails.union(ms)
-
- XCTAssertEqual(allMails.count, preMails.count + 1)
- var found = false
- for m in allMails{
- if mail?.uid == m.uid{
- found = true
- if isSecure{
- XCTAssertEqual(m.decryptedBody,body)
- }
- else{
- XCTAssertEqual(m.body, body)
- }
- XCTAssertEqual(m.subject, subject)
- XCTAssertEqual(m.date, date)
- break
- }
+ let cryptoObject3 = senderPGP.encrypt(plaintext: body , ids: [userKeyID], myId: keyID1)
+ if let oldKeyMail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject3){
+ XCTAssertTrue(oldKeyMail.isSecure)
}
- XCTAssertTrue(found)
- return mail
}
-
- func testMailAdr(mailAdr: Mail_Address, hasKey: Bool, adr: String, ezContact: EnzevalosContact, primaryKey: PersistentKey?, keys: [PersistentKey]){
- XCTAssertEqual(mailAdr.hasKey, hasKey)
- XCTAssertEqual(mailAdr.mailAddress, adr)
- XCTAssertEqual(mailAdr.contact, ezContact)
- if hasKey{
- XCTAssertNotNil(mailAdr.primaryKey)
- XCTAssertEqual(mailAdr.primaryKey?.keyID, primaryKey?.keyID)
- XCTAssertEqual(mailAdr.publicKeys.count, keys.count)
- for key in keys{
- var found = false
- for k in mailAdr.publicKeys{
- if k.keyID == key.keyID{
- found = true
- break
- }
- }
- XCTAssertTrue(found)
- // Same size && For all k in keys: k in mailAdr.keys -> mailAdr.keys == keys
- }
- }
- else{
- XCTAssertNil(mailAdr.primaryKey)
- XCTAssertEqual(mailAdr.publicKeys.count ,0)
- }
- }
-
- func testEnzContact(enzContact: EnzevalosContact, addresses: [MailAddress], from: Set<PersistentMail>, to: Set<PersistentMail>, cc: Set<PersistentMail>, bcc: Set<PersistentMail>, keys: [PersistentKey]){
- // Check addresses
- XCTAssertEqual(enzContact.addresses.count, addresses.count)
- for adr in addresses{
- var found = false
- for a in enzContact.addresses{
- if let myadr = a as? Mail_Address{
- if adr.mailAddress == myadr.mailAddress{
- found = true
- break
- }
- }
-
- }
- XCTAssertTrue(found)
- }
-
- // Check mails (from, cc, to)
- XCTAssertEqual(enzContact.from.count, from.count)
- for m in from{
- XCTAssertTrue(enzContact.from.contains(m))
- }
+ func testOwnRecord(){
+ let (sender, keyID) = createPGPUser()
+ let body = "enc with old key"
+ let folderName = "INBOX"
+
+ var myrecord = datahandler.getKeyRecord(addr: userAdr, keyID: datahandler.prefSecretKey().keyID)
+ XCTAssertEqual(myrecord.keyID, userKeyID)
+ XCTAssertEqual(myrecord.ezContact.records.count, 1)
+
- XCTAssertEqual(enzContact.to.count, to.count)
- for m in to{
- XCTAssertTrue(enzContact.to.contains(m))
- }
+ let cryptoObject1 = pgp.encrypt(plaintext: body , ids: [userKeyID], myId: keyID)
+ _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject1)
+ let myContact = datahandler.getContactByAddress(userAdr)
- XCTAssertEqual(enzContact.cc.count, cc.count)
- for m in cc{
- XCTAssertTrue(enzContact.cc.contains(m))
- }
+ if let newKeyIDs = try? pgp.importKeys(key: CryptoTests.importKey, pw: CryptoTests.importPW, isSecretKey: true, autocrypt: false), let newKeyId = newKeyIDs.first {
+ _ = datahandler.newSecretKey(keyID: newKeyId)
+ XCTAssertTrue(newKeyId == datahandler.prefSecretKey().keyID)
+ XCTAssertTrue(userKeyID != newKeyId)
+
+ let key = datahandler.findKey(keyID: datahandler.prefSecretKey().keyID!)
+ XCTAssertTrue(key?.keyID == newKeyId)
+
+ myrecord = datahandler.getKeyRecord(addr: userAdr, keyID: datahandler.prefSecretKey().keyID)
+
+
+ XCTAssertEqual(myrecord.keyID, newKeyId)
+ XCTAssertEqual(myrecord.ezContact.records.count, 2)
+ XCTAssertTrue(myrecord.isSecure)
+ XCTAssertEqual(myContact.publicKeys.count, 2)
+ let cryptoObject2 = pgp.encrypt(plaintext: body , ids: [newKeyId], myId: keyID )
+ let mail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject2)
+
+ let cryptoObject3 = pgp.encrypt(plaintext: body , ids: [userKeyID], myId: keyID)
+ let oldMail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject3)
+
+ XCTAssertTrue((oldMail?.decryptedWithOldPrivateKey)!)
+
- XCTAssertEqual(enzContact.bcc.count, bcc.count)
- for m in bcc{
- XCTAssertTrue(enzContact.bcc.contains(m))
+ } else {
+ XCTFail("No new key")
+ return
}
+ // teste, ob alle eigenen Keys da sind
- // Check Crypto
- if keys.count == 0{
- XCTAssertFalse(enzContact.hasKey)
- XCTAssertTrue(enzContact.publicKeys.count == 0)
- for a in enzContact.addresses{
- if let adr = a as? Mail_Address{
- XCTAssertFalse(adr.hasKey)
- }
- }
- }
- else{
- XCTAssertTrue(enzContact.hasKey)
- XCTAssertEqual(enzContact.publicKeys.count, keys.count)
- for key in keys{
- var found = false
- for mykey in enzContact.publicKeys{
- if key.keyID == mykey.keyID{
- found = true
- break
- }
- }
- XCTAssertTrue(found)
- }
- for a in enzContact.addresses{
- if let adr = a as? Mail_Address{
- for key in adr.publicKeys{
- var found = false
- for mykey in enzContact.publicKeys{
- if key.keyID == mykey.keyID{
- found = true
- break
- }
- }
- XCTAssertTrue(found)
- }
- }
- }
- }
+ // teste, ob das hin und herspringen klappt.
+ }
+
+ func testInbox() {
- // Check records
- XCTAssertEqual(enzContact.records.count, keys.count + 1)
- for key in keys{
- var found = false
- for record in enzContact.records{
- if record.keyID == key.keyID{
- found = true
- }
- }
- XCTAssertTrue(found)
- }
- for record in enzContact.records{
- testKeyRecord(record: record)
- }
}
- func testKeyRecord(record: KeyRecord){
- XCTAssertTrue(record.addresses.count > 0)
- //XCTAssertTrue(record.mails.count > 0) We have to consider self keyrecord...
- // Test if mails are sorted!
- if record.isSecure{
- XCTAssertNotNil(record.keyID)
- for mail in record.mails{
- XCTAssertTrue(mail.isSecure)
- }
- let mails = DataHandler.handler.allMailsInFolder(key: record.keyID, contact: nil, folder: record.folder, isSecure: record.isSecure)
- XCTAssertEqual(record.mails.count, mails.count)
- for m in mails{
- XCTAssertTrue(record.mails.contains(m))
- }
- }
- else{
- for mail in record.mails{
- XCTAssertFalse(mail.isSecure)
- }
- }
- let mails = DataHandler.handler.allMailsInFolder(key: record.keyID, contact: record.ezContact, folder: record.folder, isSecure: record.isSecure)
- XCTAssertEqual(record.mails.count, mails.count)
- for m in mails{
- XCTAssertTrue(record.mails.contains(m))
- }
- if let keyId = record.keyID{
- for adr in record.addresses{
- var found = false
- for key in adr.publicKeys{
- if key.keyID == keyId{
- found = true
- }
- }
- XCTAssertTrue(found)
- }
- var found = false
- for key in record.ezContact.publicKeys{
- if key.keyID == keyId{
- found = true
+ func checkOrderingOfRecord(record: KeyRecord) -> Bool{
+ var prev: PersistentMail?
+ for m in record.mails{
+ if let prev = prev {
+ if prev.date < m.date {
+ return false
}
}
- XCTAssertTrue(found)
- //XCTAssertTrue(keyId == record.fingerprint!)
- XCTAssertTrue(keyId == record.pgpKey?.keyID.longIdentifier)
- XCTAssertTrue(keyId == record.storedKey?.keyID)
+ prev = m
}
- else{
- XCTAssertNil(record.fingerprint)
- XCTAssertNil(record.pgpKey)
- XCTAssertNil(record.storedKey)
+ return true
+ }
+
+ func testMail(from: MCOAddress, to: [MCOAddress], cc: [MCOAddress], bcc: [MCOAddress], flags: MCOMessageFlag = MCOMessageFlag.init(rawValue: 0), folder: String = "INBOX" , date: Date = Date(timeIntervalSince1970: TimeInterval(arc4random())), cryptoObject: CryptoObject? = nil, body: String = String.random(length: 20)) -> PersistentMail?{
+
+ let subject = String.random(length: 20)
+ let id = UInt64(arc4random())
+ var body = body
+
+ if let decryptedBody = cryptoObject?.decryptedText {
+ body = decryptedBody
}
+ var mail: PersistentMail?
+ mail = datahandler.createMail(id, sender: from, receivers: to, cc: cc, time: date, received: true, subject: subject, body: body, flags: flags, record: nil, autocrypt: nil, decryptedData: cryptoObject, folderPath: folder, secretKey: nil)
+ XCTAssertNotNil(mail)
+ XCTAssertEqual(mail?.body, body)
+ XCTAssertEqual(mail?.subject, subject)
+ XCTAssertEqual(mail?.folder.name.lowercased(), folder.lowercased())
+ return mail
}
}
diff --git a/enzevalos_iphoneTests/CryptoTests.swift b/enzevalos_iphoneTests/CryptoTests.swift
index d6886d078e2cbdc31d7a8aadf7b699b62778daaa..ab0eb18597791ea5d7da9d6ceb70c270b72167b3 100644
--- a/enzevalos_iphoneTests/CryptoTests.swift
+++ b/enzevalos_iphoneTests/CryptoTests.swift
@@ -23,8 +23,8 @@ class CryptoTests: XCTestCase {
var user: MCOAddress = MCOAddress.init(mailbox: "alice@example.com")
var userKeyID: String = ""
- let importPW = "alice"
- let importKey = """
+ static let importPW = "alice"
+ static let importKey = """
-----BEGIN PGP PUBLIC KEY BLOCK-----
mQINBFq4++UBEAC9U17Z0QGKJaagEdnGVrCNDt8ic0itgmynNYq1FlZz28hpcTq0
@@ -449,7 +449,7 @@ class CryptoTests: XCTestCase {
func testimportSecretKey(){
XCTAssert(datahandler.prefSecretKey().keyID == userKeyID)
XCTAssertEqual(datahandler.findSecretKeys().count, 1)
- guard let keys = try? pgp.importKeys(key: importKey, pw: importPW, isSecretKey: true, autocrypt: false) else {
+ guard let keys = try? pgp.importKeys(key: CryptoTests.importKey, pw: CryptoTests.importPW, isSecretKey: true, autocrypt: false) else {
XCTFail("No key")
return
}
@@ -554,7 +554,7 @@ class CryptoTests: XCTestCase {
// 5. case: used old key to encrypt message
// Import a new secret key -> previous key is now an old key
- guard let keys = try? pgp.importKeys(key: importKey, pw: importPW, isSecretKey: true, autocrypt: false), keys.count > 0 else {
+ guard let keys = try? pgp.importKeys(key: CryptoTests.importKey, pw: CryptoTests.importPW, isSecretKey: true, autocrypt: false), keys.count > 0 else {
XCTFail("Can not import key")
return
}
@@ -566,4 +566,6 @@ class CryptoTests: XCTestCase {
XCTAssert(cryptoObject.encryptionState == .ValidEncryptedWithOldKey && cryptoObject.signatureState == .ValidSignature)
XCTAssert(cryptoObject.decryptedText == body)
}
+
+
}