101 lines
2.9 KiB
Swift
101 lines
2.9 KiB
Swift
//
|
|
// MockPGPInterface.swift
|
|
// passKitTests
|
|
//
|
|
|
|
import Foundation
|
|
@testable import passKit
|
|
|
|
class MockPGPInterface: PGPInterface {
|
|
// MARK: - Configuration
|
|
|
|
var publicKeyIDs: Set<String> = []
|
|
var privateKeyIDs: Set<String> = []
|
|
|
|
var decryptResult: Data?
|
|
var decryptError: Error?
|
|
var encryptResult = Data()
|
|
var encryptError: Error?
|
|
|
|
/// When set, the mock calls `passPhraseForKey` with this key ID during `decrypt`,
|
|
/// simulating the PGP backend selecting a key and requesting its passphrase.
|
|
var selectedKeyForPassphrase: String?
|
|
|
|
// MARK: - Call tracking
|
|
|
|
struct DecryptCall {
|
|
let encryptedData: Data
|
|
let keyID: String?
|
|
let passPhraseForKey: (String) -> String
|
|
}
|
|
|
|
struct EncryptCall {
|
|
let plainData: Data
|
|
let keyID: String?
|
|
}
|
|
|
|
struct EncryptMultiKeyCall {
|
|
let plainData: Data
|
|
let keyIDs: [String]
|
|
}
|
|
|
|
struct EncryptWithAllKeysCall {
|
|
let plainData: Data
|
|
}
|
|
|
|
var decryptCalls: [DecryptCall] = []
|
|
var resolvedPassphrases: [String] = []
|
|
var encryptMultiKeyCalls: [EncryptMultiKeyCall] = []
|
|
var encryptWithAllKeysCalls: [EncryptWithAllKeysCall] = []
|
|
var containsPublicKeyCalls: [String] = []
|
|
var containsPrivateKeyCalls: [String] = []
|
|
|
|
// MARK: - PGPInterface
|
|
|
|
func decrypt(encryptedData: Data, keyIDHint keyID: String?, passPhraseForKey: @escaping (String) -> String) throws -> Data? {
|
|
decryptCalls.append(DecryptCall(encryptedData: encryptedData, keyID: keyID, passPhraseForKey: passPhraseForKey))
|
|
if let selectedKey = selectedKeyForPassphrase {
|
|
resolvedPassphrases.append(passPhraseForKey(selectedKey))
|
|
}
|
|
if let error = decryptError {
|
|
throw error
|
|
}
|
|
return decryptResult
|
|
}
|
|
|
|
func encryptWithAllKeys(plainData: Data) throws -> Data {
|
|
encryptWithAllKeysCalls.append(EncryptWithAllKeysCall(plainData: plainData))
|
|
if let error = encryptError {
|
|
throw error
|
|
}
|
|
return encryptResult
|
|
}
|
|
|
|
func encrypt(plainData: Data, keyIDs: [String]) throws -> Data {
|
|
encryptMultiKeyCalls.append(EncryptMultiKeyCall(plainData: plainData, keyIDs: keyIDs))
|
|
if let error = encryptError {
|
|
throw error
|
|
}
|
|
return encryptResult
|
|
}
|
|
|
|
func containsPublicKey(with keyID: String) -> Bool {
|
|
containsPublicKeyCalls.append(keyID)
|
|
return publicKeyIDs.contains { $0.hasSuffix(keyID.lowercased()) }
|
|
}
|
|
|
|
func containsPrivateKey(with keyID: String) -> Bool {
|
|
containsPrivateKeyCalls.append(keyID)
|
|
return privateKeyIDs.contains { $0.hasSuffix(keyID.lowercased()) }
|
|
}
|
|
|
|
func getKeyIDs(type _: PGPKey) -> [String] {
|
|
// currently irrelevant for the tests
|
|
[]
|
|
}
|
|
|
|
func getShortKeyIDs(type _: PGPKey) -> [String] {
|
|
// currently irrelevant for the tests
|
|
[]
|
|
}
|
|
}
|