diff --git a/enzevalos_iphone.xcodeproj/project.pbxproj b/enzevalos_iphone.xcodeproj/project.pbxproj
index 7e1ec075a87609bde986e589c485784f6b885e18..ca94b6267a9cd0958ca3425d91aa7ee6c55c55a5 100644
--- a/enzevalos_iphone.xcodeproj/project.pbxproj
+++ b/enzevalos_iphone.xcodeproj/project.pbxproj
@@ -47,7 +47,6 @@
4707092D2189C74200DF71A3 /* bobSecret.asc in Resources */ = {isa = PBXBuildFile; fileRef = 4707092B2189C74200DF71A3 /* bobSecret.asc */; };
4707092E2189C74200DF71A3 /* alicePublic.asc in Resources */ = {isa = PBXBuildFile; fileRef = 4707092C2189C74200DF71A3 /* alicePublic.asc */; };
470709302189E1C100DF71A3 /* enc+signedThunderbird.eml in Resources */ = {isa = PBXBuildFile; fileRef = 4707092F2189E1C000DF71A3 /* enc+signedThunderbird.eml */; };
- 4715F637202A0248001BFFD0 /* CoreDataTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 4715F636202A0248001BFFD0 /* CoreDataTests.swift */; };
47184C3922F0D8F200712A7A /* CFNetwork.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 47184C3822F0D8F200712A7A /* CFNetwork.framework */; };
471876F7223FACA900912135 /* BobPWTEST1234.asc in Resources */ = {isa = PBXBuildFile; fileRef = 471876F5223FACA900912135 /* BobPWTEST1234.asc */; };
471876F8223FACA900912135 /* BobWithoutPW.asc in Resources */ = {isa = PBXBuildFile; fileRef = 471876F6223FACA900912135 /* BobWithoutPW.asc */; };
@@ -287,7 +286,6 @@
4707092B2189C74200DF71A3 /* bobSecret.asc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = bobSecret.asc; sourceTree = "<group>"; };
4707092C2189C74200DF71A3 /* alicePublic.asc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = alicePublic.asc; sourceTree = "<group>"; };
4707092F2189E1C000DF71A3 /* enc+signedThunderbird.eml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = "enc+signedThunderbird.eml"; sourceTree = "<group>"; };
- 4715F636202A0248001BFFD0 /* CoreDataTests.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = CoreDataTests.swift; sourceTree = "<group>"; };
47184C3822F0D8F200712A7A /* CFNetwork.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CFNetwork.framework; path = System/Library/Frameworks/CFNetwork.framework; sourceTree = SDKROOT; };
471876F5223FACA900912135 /* BobPWTEST1234.asc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = BobPWTEST1234.asc; sourceTree = "<group>"; };
471876F6223FACA900912135 /* BobWithoutPW.asc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = BobWithoutPW.asc; sourceTree = "<group>"; };
@@ -1326,7 +1324,6 @@
47F0376C22A7278A0005C9DE /* private */,
470709202189C24800DF71A3 /* testKeys */,
470709112189BB4A00DF71A3 /* testMails */,
- 4715F636202A0248001BFFD0 /* CoreDataTests.swift */,
A15D215E223BE6E4003E0CE0 /* MailTest.swift */,
A13526921D955BE000D3BFE1 /* Info.plist */,
F1E918D61FBDEECA00D60418 /* LoggerTests.swift */,
@@ -1922,7 +1919,6 @@
47FAE3222524C1C0005A1BCB /* CoreMailTest.swift in Sources */,
47EABF0F2420C63600774A93 /* AuthenticationTests.swift in Sources */,
988C9C5D240D507A006213F0 /* UrlStringExtensionTests.swift in Sources */,
- 4715F637202A0248001BFFD0 /* CoreDataTests.swift in Sources */,
47C22281218AFD6300BD2C2B /* AutocryptTest.swift in Sources */,
478154AE2200641900A931EC /* StudyTest.swift in Sources */,
47EABF0E2420C63600774A93 /* GeneratedMocks.swift in Sources */,
diff --git a/enzevalos_iphoneTests/CoreDataTests.swift b/enzevalos_iphoneTests/CoreDataTests.swift
deleted file mode 100644
index 9d041ae6345f5180efbaa42cd7883e68aaf7cdf2..0000000000000000000000000000000000000000
--- a/enzevalos_iphoneTests/CoreDataTests.swift
+++ /dev/null
@@ -1,371 +0,0 @@
-//
-// CoreDataTests.swift
-// enzevalos_iphoneTests
-//
-// Created by Oliver Wiese on 30.01.18.
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program. If not, see <https://www.gnu.org/licenses/>.
-//
-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
- - Test different types of Mail (sec, insecure etc.)
-
-
- TODO: Delete mail, move mail, reply mail, forward mail
- TEST MAXID in folders!
- */
-
-@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()
- pgp.resetKeychains()
- datahandler.reset()
- // XCTAssertLessThanOrEqual(datahandler.allFolders.count, 1, "Folder: \(datahandler.allFolders.map{$0.frontendName})")
- XCTAssertEqual(datahandler.findSecretKeys().count, 0)
- XCTAssertEqual(datahandler.getContacts().count, 0)
- XCTAssertEqual(datahandler.getAddresses().count, 0)
- (user, userKeyID) = owner()
- }
-
- override func tearDown() {
- datahandler.reset()
- pgp.resetKeychains()
- super.tearDown()
- }
-
- // Test for generating list of mails with missing secret key (unable to decrypt)
- func testGetAllFilteredMails() {
- guard let from = MCOAddress(mailbox: "sender@example.com")
- else {
- return
- }
- guard let m1 = testMail(from: from, to: [user], cc: [], bcc: []) else {
- XCTFail("Could not create test mails")
- return
- }
- m1.unableToDecrypt = true
- m1.secretKey = datahandler.createNewSecretKey(adr: "sender@example.com").keyID
-
- guard let m2 = testMail(from: from, to: [user], cc: [], bcc: []) else {
- XCTFail("Could not create test mails")
- return
- }
- m2.unableToDecrypt = false
- m2.secretKey = datahandler.createNewSecretKey(adr: "sender@example.com").keyID
-
- guard let m3 = testMail(from: from, to: [user], cc: [], bcc: []) else {
- XCTFail("Could not create test mails")
- return
- }
- m3.unableToDecrypt = true
- m3.secretKey = datahandler.createNewSecretKey(adr: "sender@example.com").keyID
-
- datahandler.save(during: "manipulate test mails")
-
- let mailList = datahandler.getAllNotDecryptedPersistentMail()
- XCTAssertEqual(mailList.count, 2, "Wrong length: \(mailList.count)")
- for mail in mailList {
- XCTAssertEqual(mail.unableToDecrypt, true, "Mail is unable to decrypt. The encryption state is: \(mail.encState)")
- }
- }
-
- 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)
- UserManager.storeUserValue(userName as AnyObject, attribute: Attribute.accountname)
- return (user, userid)
- }
-
- func testArrivingMail() {
- let sender = createUser()
- let folder = "INBOX"
- XCTAssertNil(datahandler.findMailAddress(adr: sender.mailbox))
-
- if let mail = testMail(from: sender, to: [user], cc: [user], bcc: [], folder: folder) {
- XCTAssertFalse(mail.isSecure)
- XCTAssertFalse(mail.isEncrypted)
- XCTAssertFalse(mail.isSigned)
- XCTAssertFalse(mail.trouble)
- XCTAssertFalse(mail.isCorrectlySigned)
-
- XCTAssert(mail.getCCs().count == 1)
- XCTAssert(mail.getCCs()[0].mailAddress == user.mailbox)
- XCTAssert(mail.getReceivers().count == 1)
- XCTAssert(mail.getReceivers()[0].mailAddress == user.mailbox)
-
-
- XCTAssertNotNil(datahandler.findMailAddress(adr: sender.mailbox))
- let f = datahandler.findFolder(with: folder)
- XCTAssertEqual(f.mailsOfFolder.count, 1)
- XCTAssertEqual(f.records.count, 1)
- var containsMail = false
- for m in f.mailsOfFolder {
- if m == mail {
- containsMail = true
- }
- }
- XCTAssertTrue(containsMail)
- var containsAddr = false
- for r in f.records {
- for a in r.addresses {
- if a.mailAddress == sender.mailbox {
- containsAddr = true
- }
- }
- }
- XCTAssertTrue(containsAddr)
- }
- else {
- XCTFail("No mail")
- }
- }
-
- func testMultiplePlainMailsFromOne() {
- let sender = createUser()
- let n = 100
- let folderName = "INBOX"
- 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)
- XCTAssertEqual(folder.mailsOfFolder.count, n)
- XCTAssertTrue(checkOrderingOfRecord(record: folder.records.first!))
- }
-
-
- 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)
- }
- }
- 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)
- }
- prev = record
- }
- }
-
- 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")
- }
- }
- 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)
- }
- else {
- insecureRecord = true
- }
- }
- XCTAssertTrue(secureRecord)
- XCTAssertTrue(insecureRecord)
- }
-
- func testNewKey() {
- let (sender, keyID1) = createPGPUser()
- let senderPGP = SwiftPGP()
- let body = "mixed mails"
- let folderName = "INBOX"
-
- let cryptoObject1 = senderPGP.encrypt(plaintext: body, ids: [userKeyID], myId: keyID1)
- _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject1)
-
- let keyID2 = pgp.generateKey(adr: sender.mailbox, new: true)
- let cryptoObject2 = senderPGP.encrypt(plaintext: body, ids: [userKeyID], myId: keyID2)
- _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject2)
-
- 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)
- }
-
- 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)
- }
- }
-
- func testOwnRecord() {
- let (sender, keyID) = createPGPUser()
- let body = "enc with old key"
- let folderName = "INBOX"
- let oldID = userKeyID
-
- var myrecord = datahandler.getKeyRecord(addr: userAdr, keyID: datahandler.prefSecretKey()?.keyID)
- XCTAssertEqual(myrecord.keyID, userKeyID)
- XCTAssertEqual(myrecord.ezContact.records.count, 1)
-
-
- let cryptoObject1 = pgp.encrypt(plaintext: body, ids: [oldID], myId: keyID)
- _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: cryptoObject1)
- let myContact = datahandler.getContactByAddress(userAdr)
-
- if let newKeyIDs = try? pgp.importKeys(key: CryptoTests.importKey, pw: CryptoTests.importPW, isSecretKey: true, autocrypt: false), let newKeyId = newKeyIDs.first{
- _ = datahandler.newSecretKey(keyID: newKeyId, addPk: true, saveKey: true)
- if let prefSK = datahandler.prefSecretKey() {
- XCTAssertTrue(newKeyId == prefSK.keyID, "newKeyID: \(newKeyId) != \(String(describing: prefSK.keyID)): prefKeyID")
- XCTAssertTrue(userKeyID != newKeyId)
-
- let key = datahandler.findSecretKey(keyID: prefSK.keyID)
- XCTAssertNotNil(key)
- XCTAssertTrue(key?.keyID == newKeyId, "newKeyID: \(newKeyId) != \(String(describing: key?.keyID)): prefKeyID")
-
- myrecord = datahandler.getKeyRecord(addr: userAdr, keyID: prefSK.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 decryptObject2 = pgp.decrypt(data: cryptoObject2.chiphertext!, decKeyIDs: [newKeyId], signatureIDs: [keyID], fromAddr: userAdr)
- _ = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: decryptObject2)
-
- let cryptoObject3 = pgp.encrypt(plaintext: body, ids: [oldID], myId: keyID)
- let decryptObject3 = pgp.decrypt(data: cryptoObject3.chiphertext!, decKeyIDs: [oldID], signatureIDs: [keyID], fromAddr: userAdr)
- let oldMail = testMail(from: sender, to: [user], cc: [], bcc: [], folder: folderName, cryptoObject: decryptObject3)
-
- XCTAssertTrue((oldMail?.decryptedWithOldPrivateKey)!)
-
-
- } else {
- XCTFail("No new key")
- return
- }
- }
-
-
- func checkOrderingOfRecord(record: KeyRecord) -> Bool {
- var prev: PersistentMail?
- for m in record.mails {
- if let prev = prev {
- if prev.date < m.date {
- return false
- }
- }
- prev = m
- }
- 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, encryptedBody: cryptoObject?.chiperString)
- XCTAssertNotNil(mail)
- XCTAssertEqual(mail?.body, body)
- XCTAssertEqual(mail?.subject, subject)
- XCTAssertEqual(mail?.folder.name.lowercased(), folder.lowercased())
-
- return mail
- }
-
- func testKeysPerAddress() {
- let adrKey = "key@example.com"
- let adrNoKey = "noKey@example.com"
- let adrNoKey2 = "noKey2@example.com"
- var mailAdrKey = datahandler.getMailAddress(adrKey, temporary: false)
- let mailAdrNoKey = datahandler.getMailAddress(adrNoKey, temporary: false)
- _ = datahandler.getMailAddress(adrNoKey2, temporary: false)
- XCTAssertFalse(mailAdrKey.hasKey)
- XCTAssertFalse(mailAdrNoKey.hasKey)
- XCTAssertEqual(datahandler.getAddresses().count, 3)
- _ = datahandler.newPublicKey(keyID: "000", cryptoType: .PGP, adr: adrKey, autocrypt: false, transferType: nil)
- _ = datahandler.newPublicKey(keyID: "001", cryptoType: .PGP, adr: adrKey, autocrypt: false, transferType: nil)
- mailAdrKey = datahandler.getMailAddress(adrKey, temporary: false)
- XCTAssertTrue(mailAdrKey.hasKey)
- let withKeys = datahandler.findMailAddress(withKey: true).count
- let noKeys = datahandler.findMailAddress(withKey: false).count
- XCTAssertEqual(withKeys, 1, "Adresses with key: \(withKeys)")
- XCTAssertEqual(noKeys, 2, "Adresses without key: \(noKeys)")
- }
-}