session-ios/Loki/FriendRequestProtocolTests.swift
2020-06-04 09:22:52 +10:00

655 lines
34 KiB
Swift

import CryptoSwift
import PromiseKit
@testable import SignalServiceKit
import XCTest
import Curve25519Kit
class FriendRequestProtocolTests : XCTestCase {
private var storage: OWSPrimaryStorage { OWSPrimaryStorage.shared() }
private var messageSender: OWSFakeMessageSender { MockSSKEnvironment.shared.messageSender as! OWSFakeMessageSender }
// MARK: - Setup
override func setUp() {
super.setUp()
LokiTestUtilities.setUpMockEnvironment()
}
// MARK: - Helpers
func isFriendRequestStatus(oneOf values: [LKFriendRequestStatus], for hexEncodedPublicKey: String, transaction: YapDatabaseReadWriteTransaction) -> Bool {
let status = storage.getFriendRequestStatus(for: hexEncodedPublicKey, transaction: transaction)
return values.contains(status)
}
func isFriendRequestStatus(_ value: LKFriendRequestStatus, for hexEncodedPublicKey: String, transaction: YapDatabaseReadWriteTransaction) -> Bool {
return isFriendRequestStatus(oneOf: [ value ], for: hexEncodedPublicKey, transaction: transaction)
}
// MARK: - shouldInputBarBeEnabled
func test_shouldInputBarBeEnabledReturnsTrueOnGroupThread() {
let allGroupTypes: [GroupType] = [ .closedGroup, .openGroup, .rssFeed ]
for groupType in allGroupTypes {
guard let groupThread = LokiTestUtilities.createGroupThread(groupType: groupType) else { return XCTFail() }
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: groupThread))
}
}
func test_shouldInputBarBeEnabledReturnsTrueOnNoteToSelf() {
guard let master = OWSIdentityManager.shared().identityKeyPair()?.hexEncodedPublicKey else { return XCTFail() }
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: masterThread))
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: slaveThread))
}
func test_shouldInputBarBeEnabledReturnsTrueWhenStatusIsNotPending() {
let statuses: [LKFriendRequestStatus] = [ .none, .requestExpired, .friends ]
let device = LokiTestUtilities.generateHexEncodedPublicKey()
let thread = LokiTestUtilities.createContactThread(for: device)
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: device, transaction: transaction)
}
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: thread))
}
}
func test_shouldInputBarBeEnabledReturnsFalseWhenStatusIsPending() {
let statuses: [LKFriendRequestStatus] = [ .requestSending, .requestSent, .requestReceived ]
let device = LokiTestUtilities.generateHexEncodedPublicKey()
let thread = LokiTestUtilities.createContactThread(for: device)
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: device, transaction: transaction)
}
XCTAssertFalse(FriendRequestProtocol.shouldInputBarBeEnabled(for: thread))
}
}
func test_shouldInputBarBeEnabledReturnsTrueWhenFriendsWithOneLinkedDevice() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.friends, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: masterThread))
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: slaveThread))
}
func test_shouldInputBarBeEnabledReturnsFalseWhenOneLinkedDeviceIsPending() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.none, for: master, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
let statuses: [LKFriendRequestStatus] = [ .requestSending, .requestSent, .requestReceived ]
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: slave, transaction: transaction)
}
XCTAssertFalse(FriendRequestProtocol.shouldInputBarBeEnabled(for: masterThread))
XCTAssertFalse(FriendRequestProtocol.shouldInputBarBeEnabled(for: slaveThread))
}
}
func test_shouldInputBarBeEnabledReturnsTrueWhenAllLinkedDevicesAreNotPendingAndNotFriends() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.none, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.none, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
let statuses: [LKFriendRequestStatus] = [ .requestExpired, .none ]
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: slave, transaction: transaction)
}
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: masterThread))
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: slaveThread))
}
}
func test_shouldInputBarEnabledShouldStillWorkIfLinkedDeviceThreadDoesNotExist() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.friends, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
XCTAssertTrue(FriendRequestProtocol.shouldInputBarBeEnabled(for: masterThread))
}
// MARK: - shouldAttachmentButtonBeEnabled
func test_shouldAttachmentButtonBeEnabledReturnsTrueOnGroupThread() {
let allGroupTypes: [GroupType] = [ .closedGroup, .openGroup, .rssFeed ]
for groupType in allGroupTypes {
guard let groupThread = LokiTestUtilities.createGroupThread(groupType: groupType) else { return XCTFail() }
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: groupThread))
}
}
func test_shouldAttachmentButtonBeEnabledReturnsTrueOnNoteToSelf() {
guard let master = OWSIdentityManager.shared().identityKeyPair()?.hexEncodedPublicKey else { return XCTFail() }
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: masterThread))
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: slaveThread))
}
func test_shouldAttachmentButtonBeEnabledReturnsTrueWhenFriends() {
let device = LokiTestUtilities.generateHexEncodedPublicKey()
let thread = LokiTestUtilities.createContactThread(for: device)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(.friends, for: device, transaction: transaction)
}
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: thread))
}
func test_shouldAttachmentButtonBeEnabledReturnsFalseWhenNotFriends() {
let statuses: [LKFriendRequestStatus] = [ .requestSending, .requestSent, .requestReceived, .none, .requestExpired ]
let device = LokiTestUtilities.generateHexEncodedPublicKey()
let thread = LokiTestUtilities.createContactThread(for: device)
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: device, transaction: transaction)
}
XCTAssertFalse(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: thread))
}
}
func test_shouldAttachmentButtonBeEnabledReturnsTrueWhenFriendsWithOneLinkedDevice() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.friends, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: masterThread))
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: slaveThread))
}
func test_shouldAttachmentButtonBeEnabledShouldStillWorkIfLinkedDeviceThreadDoesNotExist() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.none, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.friends, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
XCTAssertTrue(FriendRequestProtocol.shouldAttachmentButtonBeEnabled(for: masterThread))
}
// MARK: - getFriendRequestUIState
func test_getFriendRequestUIStateShouldReturnNoneForGroupThreads() {
let allGroupTypes: [GroupType] = [ .closedGroup, .openGroup, .rssFeed ]
for groupType in allGroupTypes {
guard let groupThread = LokiTestUtilities.createGroupThread(groupType: groupType) else { return XCTFail() }
XCTAssertTrue(FriendRequestProtocol.getFriendRequestUIStatus(for: groupThread) == .none)
}
}
func test_getFriendRequestUIStateShouldReturnNoneOnNoteToSelf() {
guard let master = OWSIdentityManager.shared().identityKeyPair()?.hexEncodedPublicKey else { return XCTFail() }
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.friends, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.friends, for: slave, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
XCTAssertTrue(FriendRequestProtocol.getFriendRequestUIStatus(for: masterThread) == .none)
XCTAssertTrue(FriendRequestProtocol.getFriendRequestUIStatus(for: slaveThread) == .none )
}
func test_getFriendRequestUIStateShouldReturnTheCorrectStates() {
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
let bobThread = LokiTestUtilities.createContactThread(for: bob)
let expectedStatuses: [LKFriendRequestStatus:FriendRequestProtocol.FriendRequestUIStatus] = [
.none: .none,
.requestExpired: .expired,
.requestSending: .sent,
.requestSent: .sent,
.requestReceived: .received,
.friends: .friends,
]
for (friendRequestStatus, uiState) in expectedStatuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(friendRequestStatus, for: bob, transaction: transaction)
}
XCTAssertEqual(FriendRequestProtocol.getFriendRequestUIStatus(for: bobThread), uiState, "Expected FriendRequestUIStatus to be \(uiState).")
}
}
func test_getFriendRequestUIStateShouldWorkWithMultiDevice() {
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.none, for: master, transaction: transaction)
}
let masterThread = LokiTestUtilities.createContactThread(for: master)
let slaveThread = LokiTestUtilities.createContactThread(for: slave)
let expectedStatuses: [LKFriendRequestStatus:FriendRequestProtocol.FriendRequestUIStatus] = [
.none: .none,
.requestExpired: .expired,
.requestSending: .sent,
.requestSent: .sent,
.requestReceived: .received,
.friends: .friends,
]
for (friendRequestStatus, uiState) in expectedStatuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(friendRequestStatus, for: slave, transaction: transaction)
}
XCTAssertEqual(FriendRequestProtocol.getFriendRequestUIStatus(for: masterThread), uiState, "Expected FriendRequestUIStatus to be \(uiState.rawValue).")
XCTAssertEqual(FriendRequestProtocol.getFriendRequestUIStatus(for: slaveThread), uiState, "Expected FriendRequestUIStatus to be \(uiState.rawValue).")
}
}
func test_getFriendRequestUIStateShouldPreferFriendsOverRequestReceived() {
// Case: We don't want to confuse the user by showing a friend request box when they're already friends.
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let masterThread = LokiTestUtilities.createContactThread(for: master)
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.friends, for: slave, transaction: transaction)
}
XCTAssertTrue(FriendRequestProtocol.getFriendRequestUIStatus(for: masterThread) == .friends)
}
func test_getFriendRequestUIStateShouldPreferReceivedOverSent() {
// Case: We sent Bob a friend request and he sent one back to us through another device.
// If something went wrong then we should be able to fall back to manually accepting the friend request even if we sent one.
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
let masterThread = LokiTestUtilities.createContactThread(for: master)
let deviceLink = DeviceLink(between: masterDevice, and: slaveDevice)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(deviceLink, in: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: slave, transaction: transaction)
}
XCTAssertTrue(FriendRequestProtocol.getFriendRequestUIStatus(for: masterThread) == .received)
}
// MARK: - acceptFriendRequest
func test_acceptFriendRequestShouldSetStatusToFriendsIfWeReceivedAFriendRequest() {
// Case: Bob sent us a friend request, we should become friends with him on accepting.
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(.requestReceived, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: bob, using: transaction)
XCTAssertTrue(self.storage.getFriendRequestStatus(for: bob, transaction: transaction) == .friends)
}
}
// TODO: Add test to see if an accept message is sent out
func test_acceptFriendRequestShouldSendAFriendRequestMessageIfStatusIsNoneOrExpired() {
// Case: Somehow our friend request status doesn't match the UI.
// Since user accepted then we should send a friend request message.
let statuses: [LKFriendRequestStatus] = [ .none, .requestExpired ]
for status in statuses {
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: bob, transaction: transaction)
}
let expectation = self.expectation(description: "Send message")
let messageSender = self.messageSender
messageSender.sendMessageWasCalledBlock = { sentMessage in
guard sentMessage is FriendRequestMessage else {
return XCTFail("Expected a friend request to be sent, but found: \(sentMessage).")
}
expectation.fulfill()
messageSender.sendMessageWasCalledBlock = nil
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: bob, using: transaction)
}
wait(for: [ expectation ], timeout: 1)
}
}
func test_acceptFriendRequestShouldNotSendAFriendRequestMessageToOurOwnDevice() {
let statuses: [LKFriendRequestStatus] = [ .none, .requestExpired ]
for status in statuses {
let ourDevice = LokiTestUtilities.getCurrentUserHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: ourDevice, transaction: transaction)
}
let expectation = self.expectation(description: "Send message")
let messageSender = self.messageSender
messageSender.sendMessageWasCalledBlock = { sentMessage in
XCTFail("Expected message not to be sent.")
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: ourDevice, using: transaction)
}
expectation.fulfillAfter(2)
wait(for: [ expectation ], timeout: 2)
messageSender.sendMessageWasCalledBlock = nil
}
}
func test_acceptFriendRequestShouldNotDoAnythingIfRequestHasBeenSent() {
// Case: We sent Bob a friend request.
// We can't accept because we don't have keys to communicate with Bob.
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(.requestSent, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: bob, using: transaction)
XCTAssertTrue(self.isFriendRequestStatus(.requestSent, for: bob, transaction: transaction))
}
}
func test_acceptFriendRequestShouldWorkWithMultiDevice() {
// Case: Bob sent a friend request from his slave device.
// Accepting the friend request should set it to friends.
// We should also send out a friend request to Bob's other devices if possible.
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
let otherSlave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
guard let otherSlaveDevice = LokiTestUtilities.getDevice(for: otherSlave) else { return XCTFail() }
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(DeviceLink(between: masterDevice, and: slaveDevice), in: transaction)
self.storage.addDeviceLink(DeviceLink(between: masterDevice, and: otherSlaveDevice), in: transaction)
self.storage.setFriendRequestStatus(.none, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: slave, transaction: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: otherSlave, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: master, using: transaction)
}
eventually {
self.storage.dbReadWriteConnection.readWrite { transaction in
// TODO: Re-enable this case when we split friend request logic from OWSMessageSender
// XCTAssertTrue(self.isFriendRequestStatus([ .requestSending, .requestSent ], for: master, transaction: transaction))
XCTAssertTrue(self.isFriendRequestStatus(.friends, for: slave, transaction: transaction))
XCTAssertTrue(self.isFriendRequestStatus(.requestSent, for: otherSlave, transaction: transaction))
}
}
}
func test_acceptFriendRequestShouldNotChangeStatusIfDevicesAreNotLinked() {
let alice = LokiTestUtilities.generateHexEncodedPublicKey()
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(.requestReceived, for: alice, transaction: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.acceptFriendRequest(from: alice, using: transaction)
XCTAssertTrue(self.isFriendRequestStatus(.friends, for: alice, transaction: transaction))
XCTAssertTrue(self.isFriendRequestStatus(.requestReceived, for: bob, transaction: transaction))
}
}
// MARK: - declineFriendRequest
func test_declineFriendRequestShouldChangeStatusFromReceivedToNone() {
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(.requestReceived, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.declineFriendRequest(from: bob, using: transaction)
XCTAssertTrue(self.isFriendRequestStatus(.none, for: bob, transaction: transaction))
}
}
func test_declineFriendRequestShouldNotChangeStatusToNoneFromOtherStatuses() {
let statuses: [LKFriendRequestStatus] = [ .none, .requestSending, .requestSent, .requestExpired, .friends ]
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
for status in statuses {
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setFriendRequestStatus(status, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.declineFriendRequest(from: bob, using: transaction)
XCTAssertTrue(self.isFriendRequestStatus(status, for: bob, transaction: transaction))
}
}
}
func test_declineFriendRequestShouldDeletePreKeyBundleIfNeeded() {
let shouldExpectDeletedPreKeyBundle: (LKFriendRequestStatus) -> Bool = { status in
return status == .requestReceived
}
let statuses: [LKFriendRequestStatus] = [ .none, .requestSending, .requestSent, .requestReceived, .requestExpired, .friends ]
for status in statuses {
let bob = LokiTestUtilities.generateHexEncodedPublicKey()
let bundle = storage.generatePreKeyBundle(forContact: bob)
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.setPreKeyBundle(bundle, forContact: bob, transaction: transaction)
self.storage.setFriendRequestStatus(status, for: bob, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.declineFriendRequest(from: bob, using: transaction)
}
let storedBundle = storage.getPreKeyBundle(forContact: bob)
if (shouldExpectDeletedPreKeyBundle(status)) {
XCTAssertNil(storedBundle, "Expected PreKeyBundle to be deleted for friend request status \(status.rawValue).")
} else {
XCTAssertNotNil(storedBundle, "Expected PreKeyBundle to not be deleted for friend request status \(status.rawValue).")
}
}
}
func test_declineFriendRequestShouldWorkWithMultipleLinkedDevices() {
// Case: Bob sends 2 friend requests to Alice.
// When Alice declines, it should change the statuses from requestReceived to none so friend request logic can be re-triggered.
let master = LokiTestUtilities.generateHexEncodedPublicKey()
let slave = LokiTestUtilities.generateHexEncodedPublicKey()
let otherSlave = LokiTestUtilities.generateHexEncodedPublicKey()
guard let masterDevice = LokiTestUtilities.getDevice(for: master) else { return XCTFail() }
guard let slaveDevice = LokiTestUtilities.getDevice(for: slave) else { return XCTFail() }
guard let otherSlaveDevice = LokiTestUtilities.getDevice(for: otherSlave) else { return XCTFail() }
storage.dbReadWriteConnection.readWrite { transaction in
self.storage.addDeviceLink(DeviceLink(between: masterDevice, and: slaveDevice), in: transaction)
self.storage.addDeviceLink(DeviceLink(between: masterDevice, and: otherSlaveDevice), in: transaction)
self.storage.setFriendRequestStatus(.requestSent, for: master, transaction: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: slave, transaction: transaction)
self.storage.setFriendRequestStatus(.requestReceived, for: otherSlave, transaction: transaction)
}
storage.dbReadWriteConnection.readWrite { transaction in
FriendRequestProtocol.declineFriendRequest(from: master, using: transaction)
XCTAssertTrue(self.isFriendRequestStatus(.requestSent, for: master, transaction: transaction))
XCTAssertTrue(self.isFriendRequestStatus(.none, for: slave, transaction: transaction))
XCTAssertTrue(self.isFriendRequestStatus(.none, for: otherSlave, transaction: transaction))
}
}
// MARK: - shouldUpdateFriendRequestStatus
func test_shouldUpdateFriendRequestStatusReturnsTheCorrectValue() {
let thread = LokiTestUtilities.createContactThread(for: LokiTestUtilities.generateHexEncodedPublicKey())
let message = TSOutgoingMessage(in: thread, messageBody: nil, attachmentId: nil)
let friendRequest = FriendRequestMessage(timestamp: 1, thread: thread, body: "")
let sessionRequest = SessionRequestMessage(thread: thread)
guard let deviceLinkRequest = DeviceLinkMessage(in: thread, masterHexEncodedPublicKey: "", slaveHexEncodedPublicKey: "", masterSignature: nil, slaveSignature: Data(capacity: 0)),
let deviceLinkAuthorisation = DeviceLinkMessage(in: thread, masterHexEncodedPublicKey: "", slaveHexEncodedPublicKey: "", masterSignature: Data(capacity: 0), slaveSignature: Data(capacity: 0)) else { return XCTFail() }
XCTAssertTrue(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: friendRequest))
XCTAssertTrue(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: deviceLinkRequest))
XCTAssertFalse(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: message))
XCTAssertFalse(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: sessionRequest))
XCTAssertFalse(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: deviceLinkAuthorisation))
}
func test_shouldUpdateFriendRequestStatusReturnsFalseForGroupThreads() {
let allGroupTypes: [GroupType] = [ .closedGroup, .openGroup, .rssFeed ]
for groupType in allGroupTypes {
guard let groupThread = LokiTestUtilities.createGroupThread(groupType: groupType) else { return XCTFail() }
let friendRequest = FriendRequestMessage(timestamp: 1, thread: groupThread, body: "")
XCTAssertFalse(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: friendRequest))
}
}
func test_shouldUpdateFriendRequestStatusReturnsFalseForCurrentDevice() {
let thread = LokiTestUtilities.createContactThread(for: LokiTestUtilities.getCurrentUserHexEncodedPublicKey())
let friendRequest = FriendRequestMessage(timestamp: 1, thread: thread, body: "")
XCTAssertFalse(FriendRequestProtocol.shouldUpdateFriendRequestStatus(from: friendRequest))
}
}