mirror of https://github.com/oxen-io/session-ios
You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2648 lines
133 KiB
Swift
2648 lines
133 KiB
Swift
// Copyright © 2022 Rangeproof Pty Ltd. All rights reserved.
|
|
|
|
import PromiseKit
|
|
import Sodium
|
|
import SessionSnodeKit
|
|
|
|
import Quick
|
|
import Nimble
|
|
|
|
@testable import SessionMessagingKit
|
|
|
|
class OpenGroupAPISpec: QuickSpec {
|
|
struct TestNonce16Generator: NonceGenerator16ByteType {
|
|
var NonceBytes: Int = 16
|
|
|
|
func nonce() -> Array<UInt8> { return Data(base64Encoded: "pK6YRtQApl4NhECGizF0Cg==")!.bytes }
|
|
}
|
|
|
|
struct TestNonce24Generator: NonceGenerator24ByteType {
|
|
var NonceBytes: Int = 24
|
|
|
|
func nonce() -> Array<UInt8> { return Data(base64Encoded: "pbTUizreT0sqJ2R2LloseQDyVL2RYztD")!.bytes }
|
|
}
|
|
|
|
// MARK: - Spec
|
|
|
|
override func spec() {
|
|
var mockStorage: MockStorage!
|
|
var mockSodium: MockSodium!
|
|
var mockAeadXChaCha20Poly1305Ietf: MockAeadXChaCha20Poly1305Ietf!
|
|
var mockSign: MockSign!
|
|
var mockGenericHash: MockGenericHash!
|
|
var mockEd25519: MockEd25519!
|
|
var dependencies: Dependencies!
|
|
|
|
var response: (OnionRequestResponseInfoType, Codable)? = nil
|
|
var pollResponse: [OpenGroupAPI.Endpoint: (OnionRequestResponseInfoType, Codable?)]?
|
|
var error: Error?
|
|
|
|
describe("an OpenGroupAPI") {
|
|
// MARK: - Configuration
|
|
|
|
beforeEach {
|
|
mockStorage = MockStorage()
|
|
mockSodium = MockSodium()
|
|
mockAeadXChaCha20Poly1305Ietf = MockAeadXChaCha20Poly1305Ietf()
|
|
mockSign = MockSign()
|
|
mockGenericHash = MockGenericHash()
|
|
mockEd25519 = MockEd25519()
|
|
dependencies = Dependencies(
|
|
onionApi: TestOnionRequestAPI.self,
|
|
storage: mockStorage,
|
|
sodium: mockSodium,
|
|
aeadXChaCha20Poly1305Ietf: mockAeadXChaCha20Poly1305Ietf,
|
|
sign: mockSign,
|
|
genericHash: mockGenericHash,
|
|
ed25519: mockEd25519,
|
|
nonceGenerator16: TestNonce16Generator(),
|
|
nonceGenerator24: TestNonce24Generator(),
|
|
date: Date(timeIntervalSince1970: 1234567890)
|
|
)
|
|
|
|
mockStorage
|
|
.when { $0.write(with: { _ in }) }
|
|
.then { args in (args.first as? ((Any) -> Void))?(any()) }
|
|
.thenReturn(Promise.value(()))
|
|
mockStorage
|
|
.when { $0.write(with: { _ in }, completion: { }) }
|
|
.then { args in
|
|
(args.first as? ((Any) -> Void))?(any())
|
|
(args.last as? (() -> Void))?()
|
|
}
|
|
.thenReturn(Promise.value(()))
|
|
mockStorage
|
|
.when { $0.getUserKeyPair() }
|
|
.thenReturn(
|
|
try! ECKeyPair(
|
|
publicKeyData: Data.data(fromHex: TestConstants.publicKey)!,
|
|
privateKeyData: Data.data(fromHex: TestConstants.privateKey)!
|
|
)
|
|
)
|
|
mockStorage
|
|
.when { $0.getUserED25519KeyPair() }
|
|
.thenReturn(
|
|
Box.KeyPair(
|
|
publicKey: Data.data(fromHex: TestConstants.publicKey)!.bytes,
|
|
secretKey: Data.data(fromHex: TestConstants.edSecretKey)!.bytes
|
|
)
|
|
)
|
|
mockStorage
|
|
.when { $0.getAllOpenGroups() }
|
|
.thenReturn([
|
|
"0": OpenGroup(
|
|
server: "testServer",
|
|
room: "testRoom",
|
|
publicKey: TestConstants.publicKey,
|
|
name: "Test",
|
|
groupDescription: nil,
|
|
imageID: nil,
|
|
infoUpdates: 0
|
|
)
|
|
])
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: [])
|
|
)
|
|
)
|
|
mockStorage
|
|
.when { $0.getOpenGroupPublicKey(for: any()) }
|
|
.thenReturn(TestConstants.publicKey)
|
|
mockStorage.when { $0.getOpenGroupSequenceNumber(for: any(), on: any()) }.thenReturn(nil)
|
|
mockStorage.when { $0.getOpenGroupInboxLatestMessageId(for: any()) }.thenReturn(nil)
|
|
mockStorage.when { $0.getOpenGroupOutboxLatestMessageId(for: any()) }.thenReturn(nil)
|
|
mockStorage.when { $0.addReceivedMessageTimestamp(any(), using: any()) }.thenReturn(())
|
|
|
|
mockGenericHash.when { $0.hash(message: any(), outputLength: any()) }.thenReturn([])
|
|
mockSodium
|
|
.when { $0.blindedKeyPair(serverPublicKey: any(), edKeyPair: any(), genericHash: mockGenericHash) }
|
|
.thenReturn(
|
|
Box.KeyPair(
|
|
publicKey: Data.data(fromHex: TestConstants.publicKey)!.bytes,
|
|
secretKey: Data.data(fromHex: TestConstants.edSecretKey)!.bytes
|
|
)
|
|
)
|
|
mockSodium
|
|
.when {
|
|
$0.sogsSignature(
|
|
message: any(),
|
|
secretKey: any(),
|
|
blindedSecretKey: any(),
|
|
blindedPublicKey: any()
|
|
)
|
|
}
|
|
.thenReturn("TestSogsSignature".bytes)
|
|
mockSign.when { $0.signature(message: any(), secretKey: any()) }.thenReturn("TestSignature".bytes)
|
|
mockEd25519.when { try $0.sign(data: any(), keyPair: any()) }.thenReturn("TestStandardSignature".bytes)
|
|
}
|
|
|
|
afterEach {
|
|
mockStorage = nil
|
|
mockSodium = nil
|
|
mockAeadXChaCha20Poly1305Ietf = nil
|
|
mockSign = nil
|
|
mockGenericHash = nil
|
|
mockEd25519 = nil
|
|
dependencies = nil
|
|
|
|
response = nil
|
|
pollResponse = nil
|
|
error = nil
|
|
}
|
|
|
|
// MARK: - Batching & Polling
|
|
|
|
context("when polling") {
|
|
context("and given a correct response") {
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.Capabilities(capabilities: [], missing: nil),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: try! JSONDecoder().decode(
|
|
OpenGroupAPI.RoomPollInfo.self,
|
|
from: """
|
|
{
|
|
\"token\":\"test\",
|
|
\"active_users\":1,
|
|
\"read\":true,
|
|
\"write\":true,
|
|
\"upload\":true
|
|
}
|
|
""".data(using: .utf8)!
|
|
),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: [OpenGroupAPI.Message](),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: [OpenGroupAPI.DirectMessage](),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: [OpenGroupAPI.DirectMessage](),
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
it("generates the correct request") {
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(pollResponse?.values).to(haveCount(5))
|
|
expect(pollResponse?.keys).to(contain(.capabilities))
|
|
expect(pollResponse?.keys).to(contain(.roomPollInfo("testRoom", 0)))
|
|
expect(pollResponse?.keys).to(contain(.roomMessagesRecent("testRoom")))
|
|
expect(pollResponse?.keys).to(contain(.inbox))
|
|
expect(pollResponse?.keys).to(contain(.outbox))
|
|
expect(pollResponse?[.capabilities]?.0).to(beAKindOf(TestOnionRequestAPI.ResponseInfo.self))
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (pollResponse?[.capabilities]?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.urlString).to(equal("testServer/batch"))
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.publicKey).to(equal("7aecdcade88d881d2327ab011afd2e04c2ec6acffc9e9df45aaf78a151bd2f7d"))
|
|
}
|
|
|
|
it("retrieves recent messages if there was no last message") {
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: false,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.roomMessagesRecent("testRoom")))
|
|
}
|
|
|
|
it("retrieves recent messages if there was a last message and it has not performed the initial poll and the last message was too long ago") {
|
|
mockStorage.when { $0.getOpenGroupSequenceNumber(for: any(), on: any()) }.thenReturn(123)
|
|
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: false,
|
|
timeSinceLastPoll: (OpenGroupAPI.Poller.maxInactivityPeriod + 1),
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.roomMessagesRecent("testRoom")))
|
|
}
|
|
|
|
it("retrieves recent messages if there was a last message and it has performed an initial poll but it was not too long ago") {
|
|
mockStorage.when { $0.getOpenGroupSequenceNumber(for: any(), on: any()) }.thenReturn(123)
|
|
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: false,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.roomMessagesSince("testRoom", seqNo: 123)))
|
|
}
|
|
|
|
it("retrieves recent messages if there was a last message and there has already been a poll this session") {
|
|
mockStorage.when { $0.getOpenGroupSequenceNumber(for: any(), on: any()) }.thenReturn(123)
|
|
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: true,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.roomMessagesSince("testRoom", seqNo: 123)))
|
|
}
|
|
|
|
it("retrieves recent inbox messages if there was no last message") {
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: true,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.inbox))
|
|
}
|
|
|
|
it("retrieves inbox messages since the last message if there was one") {
|
|
mockStorage.when { $0.getOpenGroupInboxLatestMessageId(for: any()) }.thenReturn(124)
|
|
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: true,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.inboxSince(id: 124)))
|
|
}
|
|
|
|
it("retrieves recent outbox messages if there was no last message") {
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: true,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.outbox))
|
|
}
|
|
|
|
it("retrieves outbox messages since the last message if there was one") {
|
|
mockStorage.when { $0.getOpenGroupOutboxLatestMessageId(for: any()) }.thenReturn(125)
|
|
|
|
OpenGroupAPI
|
|
.poll(
|
|
"testServer",
|
|
hasPerformedInitialPoll: true,
|
|
timeSinceLastPoll: 0,
|
|
using: dependencies
|
|
)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(pollResponse)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(pollResponse?.keys).to(contain(.outboxSince(id: 125)))
|
|
}
|
|
}
|
|
|
|
context("and given an invalid response") {
|
|
it("errors when no data is returned") {
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
|
|
it("errors when invalid data is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
|
|
it("errors when an empty array is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return "[]".data(using: .utf8) }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
|
|
it("errors when an empty object is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return "{}".data(using: .utf8) }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
|
|
it("errors when a different number of responses are returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.Capabilities(capabilities: [], missing: nil),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: try! JSONDecoder().decode(
|
|
OpenGroupAPI.RoomPollInfo.self,
|
|
from: """
|
|
{
|
|
\"token\":\"test\",
|
|
\"active_users\":1,
|
|
\"read\":true,
|
|
\"write\":true,
|
|
\"upload\":true
|
|
}
|
|
""".data(using: .utf8)!
|
|
),
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
|
|
it("errors when an unexpected response is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.PinnedMessage(id: 1, pinnedAt: 1, pinnedBy: ""),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.PinnedMessage(id: 1, pinnedAt: 1, pinnedBy: ""),
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.PinnedMessage(id: 1, pinnedAt: 1, pinnedBy: ""),
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.poll("testServer", hasPerformedInitialPoll: false, timeSinceLastPoll: 0, using: dependencies)
|
|
.get { result in pollResponse = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(pollResponse).to(beNil())
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Capabilities
|
|
|
|
context("when doing a capabilities request") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let data: OpenGroupAPI.Capabilities = OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: nil)
|
|
|
|
override class var mockResponse: Data? { try! JSONEncoder().encode(data) }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Capabilities)?
|
|
|
|
OpenGroupAPI.capabilities(on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.data).to(equal(TestApi.data))
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/capabilities"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Rooms
|
|
|
|
context("when doing a rooms request") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let data: [OpenGroupAPI.Room] = [
|
|
OpenGroupAPI.Room(
|
|
token: "test",
|
|
name: "test",
|
|
description: nil,
|
|
infoUpdates: 0,
|
|
messageSequence: 0,
|
|
created: 0,
|
|
activeUsers: 0,
|
|
activeUsersCutoff: 0,
|
|
imageId: nil,
|
|
pinnedMessages: nil,
|
|
admin: false,
|
|
globalAdmin: false,
|
|
admins: [],
|
|
hiddenAdmins: nil,
|
|
moderator: false,
|
|
globalModerator: false,
|
|
moderators: [],
|
|
hiddenModerators: nil,
|
|
read: false,
|
|
defaultRead: nil,
|
|
defaultAccessible: nil,
|
|
write: false,
|
|
defaultWrite: nil,
|
|
upload: false,
|
|
defaultUpload: nil
|
|
)
|
|
]
|
|
|
|
override class var mockResponse: Data? { return try! JSONEncoder().encode(data) }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: [OpenGroupAPI.Room])?
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.data).to(equal(TestApi.data))
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/rooms"))
|
|
}
|
|
}
|
|
|
|
// MARK: - CapabilitiesAndRoom
|
|
|
|
context("when doing a capabilitiesAndRoom request") {
|
|
context("and given a correct response") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let capabilitiesData: OpenGroupAPI.Capabilities = OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: nil)
|
|
static let roomData: OpenGroupAPI.Room = OpenGroupAPI.Room(
|
|
token: "test",
|
|
name: "test",
|
|
description: nil,
|
|
infoUpdates: 0,
|
|
messageSequence: 0,
|
|
created: 0,
|
|
activeUsers: 0,
|
|
activeUsersCutoff: 0,
|
|
imageId: nil,
|
|
pinnedMessages: nil,
|
|
admin: false,
|
|
globalAdmin: false,
|
|
admins: [],
|
|
hiddenAdmins: nil,
|
|
moderator: false,
|
|
globalModerator: false,
|
|
moderators: [],
|
|
hiddenModerators: nil,
|
|
read: false,
|
|
defaultRead: nil,
|
|
defaultAccessible: nil,
|
|
write: false,
|
|
defaultWrite: nil,
|
|
upload: false,
|
|
defaultUpload: nil
|
|
)
|
|
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: capabilitiesData,
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: roomData,
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (capabilities: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Capabilities?), room: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Room?))?
|
|
|
|
OpenGroupAPI.capabilitiesAndRoom(for: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.capabilities.data).to(equal(TestApi.capabilitiesData))
|
|
expect(response?.room.data).to(equal(TestApi.roomData))
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.capabilities.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/sequence"))
|
|
}
|
|
}
|
|
|
|
context("and given an invalid response") {
|
|
it("errors when only a capabilities response is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let capabilitiesData: OpenGroupAPI.Capabilities = OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: nil)
|
|
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: capabilitiesData,
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (capabilities: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Capabilities?), room: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Room?))?
|
|
|
|
OpenGroupAPI.capabilitiesAndRoom(for: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("errors when only a room response is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let roomData: OpenGroupAPI.Room = OpenGroupAPI.Room(
|
|
token: "test",
|
|
name: "test",
|
|
description: nil,
|
|
infoUpdates: 0,
|
|
messageSequence: 0,
|
|
created: 0,
|
|
activeUsers: 0,
|
|
activeUsersCutoff: 0,
|
|
imageId: nil,
|
|
pinnedMessages: nil,
|
|
admin: false,
|
|
globalAdmin: false,
|
|
admins: [],
|
|
hiddenAdmins: nil,
|
|
moderator: false,
|
|
globalModerator: false,
|
|
moderators: [],
|
|
hiddenModerators: nil,
|
|
read: false,
|
|
defaultRead: nil,
|
|
defaultAccessible: nil,
|
|
write: false,
|
|
defaultWrite: nil,
|
|
upload: false,
|
|
defaultUpload: nil
|
|
)
|
|
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: roomData,
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (capabilities: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Capabilities?), room: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Room?))?
|
|
|
|
OpenGroupAPI.capabilitiesAndRoom(for: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("errors when an extra response is returned") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let capabilitiesData: OpenGroupAPI.Capabilities = OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: nil)
|
|
static let roomData: OpenGroupAPI.Room = OpenGroupAPI.Room(
|
|
token: "test",
|
|
name: "test",
|
|
description: nil,
|
|
infoUpdates: 0,
|
|
messageSequence: 0,
|
|
created: 0,
|
|
activeUsers: 0,
|
|
activeUsersCutoff: 0,
|
|
imageId: nil,
|
|
pinnedMessages: nil,
|
|
admin: false,
|
|
globalAdmin: false,
|
|
admins: [],
|
|
hiddenAdmins: nil,
|
|
moderator: false,
|
|
globalModerator: false,
|
|
moderators: [],
|
|
hiddenModerators: nil,
|
|
read: false,
|
|
defaultRead: nil,
|
|
defaultAccessible: nil,
|
|
write: false,
|
|
defaultWrite: nil,
|
|
upload: false,
|
|
defaultUpload: nil
|
|
)
|
|
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: capabilitiesData,
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: roomData,
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse(
|
|
code: 200,
|
|
headers: [:],
|
|
body: OpenGroupAPI.PinnedMessage(id: 1, pinnedAt: 1, pinnedBy: ""),
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (capabilities: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Capabilities?), room: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Room?))?
|
|
|
|
OpenGroupAPI.capabilitiesAndRoom(for: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.parsingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
}
|
|
|
|
// MARK: - Messages
|
|
|
|
context("when sending messages") {
|
|
var messageData: OpenGroupAPI.Message!
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let data: OpenGroupAPI.Message = OpenGroupAPI.Message(
|
|
id: 126,
|
|
sender: "testSender",
|
|
posted: 321,
|
|
edited: nil,
|
|
seqNo: 10,
|
|
whisper: false,
|
|
whisperMods: false,
|
|
whisperTo: nil,
|
|
base64EncodedData: nil,
|
|
base64EncodedSignature: nil
|
|
)
|
|
|
|
override class var mockResponse: Data? { return try! JSONEncoder().encode(data) }
|
|
}
|
|
messageData = TestApi.data
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
messageData = nil
|
|
}
|
|
|
|
it("correctly sends the message") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.data).to(equal(messageData))
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/message"))
|
|
}
|
|
|
|
it("saves the received message timestamp to the database in milliseconds") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(mockStorage)
|
|
.to(call(matchingParameters: true) {
|
|
$0.addReceivedMessageTimestamp(321000, using: any())
|
|
})
|
|
}
|
|
|
|
context("when unblinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs the message correctly") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request body
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.SendMessageRequest = try! JSONDecoder().decode(OpenGroupAPI.SendMessageRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.data).to(equal("test".data(using: .utf8)))
|
|
expect(requestBody.signature).to(equal("TestStandardSignature".data(using: .utf8)))
|
|
}
|
|
|
|
it("fails to sign if there is no public key") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if there is no user key pair") {
|
|
mockStorage.when { $0.getUserKeyPair() }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if no signature is generated") {
|
|
mockEd25519.reset() // The 'keyPair' value doesn't equate so have to explicitly reset
|
|
mockEd25519.when { try $0.sign(data: any(), keyPair: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
|
|
context("when blinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs, .blind], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs the message correctly") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request body
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.SendMessageRequest = try! JSONDecoder().decode(OpenGroupAPI.SendMessageRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.data).to(equal("test".data(using: .utf8)))
|
|
expect(requestBody.signature).to(equal("TestSogsSignature".data(using: .utf8)))
|
|
}
|
|
|
|
it("fails to sign if there is no public key") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if there is no ed key pair key") {
|
|
mockStorage.when { $0.getUserED25519KeyPair() }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if no signature is generated") {
|
|
mockSodium
|
|
.when { $0.sogsSignature(message: any(), secretKey: any(), blindedSecretKey: any(), blindedPublicKey: any()) }
|
|
.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
to: "testRoom",
|
|
on: "testServer",
|
|
whisperTo: nil,
|
|
whisperMods: false,
|
|
fileIds: nil,
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
}
|
|
|
|
context("when getting an individual message") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let data: OpenGroupAPI.Message = OpenGroupAPI.Message(
|
|
id: 126,
|
|
sender: "testSender",
|
|
posted: 321,
|
|
edited: nil,
|
|
seqNo: 10,
|
|
whisper: false,
|
|
whisperMods: false,
|
|
whisperTo: nil,
|
|
base64EncodedData: nil,
|
|
base64EncodedSignature: nil
|
|
)
|
|
|
|
override class var mockResponse: Data? { return try! JSONEncoder().encode(data) }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.Message)?
|
|
|
|
OpenGroupAPI.message(123, in: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.data).to(equal(TestApi.data))
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/message/123"))
|
|
}
|
|
}
|
|
|
|
context("when updating a message") {
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
mockStorage.when { $0.getUserED25519KeyPair() }.thenReturn(Box.KeyPair(publicKey: [], secretKey: []))
|
|
}
|
|
|
|
it("correctly sends the update") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("PUT"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/message/123"))
|
|
}
|
|
|
|
context("when unblinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs the message correctly") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request body
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UpdateMessageRequest = try! JSONDecoder().decode(OpenGroupAPI.UpdateMessageRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.data).to(equal("test".data(using: .utf8)))
|
|
expect(requestBody.signature).to(equal("TestStandardSignature".data(using: .utf8)))
|
|
}
|
|
|
|
it("fails to sign if there is no public key") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if there is no user key pair") {
|
|
mockStorage.when { $0.getUserKeyPair() }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if no signature is generated") {
|
|
mockEd25519.reset() // The 'keyPair' value doesn't equate so have to explicitly reset
|
|
mockEd25519.when { try $0.sign(data: any(), keyPair: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
|
|
context("when blinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs, .blind], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs the message correctly") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request body
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UpdateMessageRequest = try! JSONDecoder().decode(OpenGroupAPI.UpdateMessageRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.data).to(equal("test".data(using: .utf8)))
|
|
expect(requestBody.signature).to(equal("TestSogsSignature".data(using: .utf8)))
|
|
}
|
|
|
|
it("fails to sign if there is no public key") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if there is no ed key pair key") {
|
|
mockStorage.when { $0.getUserED25519KeyPair() }.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails to sign if no signature is generated") {
|
|
mockSodium
|
|
.when { $0.sogsSignature(message: any(), secretKey: any(), blindedSecretKey: any(), blindedPublicKey: any()) }
|
|
.thenReturn(nil)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI
|
|
.messageUpdate(
|
|
123,
|
|
plaintext: "test".data(using: .utf8)!,
|
|
fileIds: nil,
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
}
|
|
|
|
context("when deleting a message") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
OpenGroupAPI.messageDelete(123, in: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("DELETE"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/message/123"))
|
|
}
|
|
}
|
|
|
|
context("when deleting all messages for a user") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
response = nil
|
|
}
|
|
|
|
it("generates the request and handles the response correctly") {
|
|
OpenGroupAPI
|
|
.messagesDeleteAll(
|
|
"testUserId",
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("DELETE"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/all/testUserId"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Pinning
|
|
|
|
context("when pinning a message") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: OnionRequestResponseInfoType?
|
|
|
|
OpenGroupAPI.pinMessage(id: 123, in: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/pin/123"))
|
|
}
|
|
}
|
|
|
|
context("when unpinning a message") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: OnionRequestResponseInfoType?
|
|
|
|
OpenGroupAPI.unpinMessage(id: 123, in: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/unpin/123"))
|
|
}
|
|
}
|
|
|
|
context("when unpinning all messages") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
var response: OnionRequestResponseInfoType?
|
|
|
|
OpenGroupAPI.unpinAll(in: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/unpin/all"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Files
|
|
|
|
context("when uploading files") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
return try! JSONEncoder().encode(FileUploadResponse(id: "1"))
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.uploadFile([], to: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/file"))
|
|
}
|
|
|
|
it("doesn't add a fileName to the content-disposition header when not provided") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
return try! JSONEncoder().encode(FileUploadResponse(id: "1"))
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.uploadFile([], to: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.headers[Header.contentDisposition.rawValue])
|
|
.toNot(contain("filename"))
|
|
}
|
|
|
|
it("adds the fileName to the content-disposition header when provided") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
return try! JSONEncoder().encode(FileUploadResponse(id: "1"))
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.uploadFile([], fileName: "TestFileName", to: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.headers[Header.contentDisposition.rawValue]).to(contain("TestFileName"))
|
|
}
|
|
}
|
|
|
|
context("when downloading files") {
|
|
it("generates the request and handles the response correctly") {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
return Data()
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
|
|
OpenGroupAPI.downloadFile(1, from: "testRoom", on: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/room/testRoom/file/1"))
|
|
}
|
|
}
|
|
|
|
// MARK: - Inbox/Outbox (Message Requests)
|
|
|
|
context("when sending message requests") {
|
|
var messageData: OpenGroupAPI.SendDirectMessageResponse!
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
static let data: OpenGroupAPI.SendDirectMessageResponse = OpenGroupAPI.SendDirectMessageResponse(
|
|
id: 126,
|
|
sender: "testSender",
|
|
recipient: "testRecipient",
|
|
posted: 321,
|
|
expires: 456
|
|
)
|
|
|
|
override class var mockResponse: Data? { return try! JSONEncoder().encode(data) }
|
|
}
|
|
messageData = TestApi.data
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
messageData = nil
|
|
}
|
|
|
|
it("correctly sends the message request") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.SendDirectMessageResponse)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
toInboxFor: "testUserId",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate the response data
|
|
expect(response?.data).to(equal(messageData))
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/inbox/testUserId"))
|
|
}
|
|
|
|
it("saves the received message timestamp to the database in milliseconds") {
|
|
var response: (info: OnionRequestResponseInfoType, data: OpenGroupAPI.SendDirectMessageResponse)?
|
|
|
|
OpenGroupAPI
|
|
.send(
|
|
"test".data(using: .utf8)!,
|
|
toInboxFor: "testUserId",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
expect(mockStorage)
|
|
.to(call(matchingParameters: true) {
|
|
$0.addReceivedMessageTimestamp(321000, using: any())
|
|
})
|
|
}
|
|
}
|
|
|
|
// MARK: - Users
|
|
|
|
context("when banning a user") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
response = nil
|
|
}
|
|
|
|
it("generates the request and handles the response correctly") {
|
|
OpenGroupAPI
|
|
.userBan(
|
|
"testUserId",
|
|
for: nil,
|
|
from: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/user/testUserId/ban"))
|
|
}
|
|
|
|
it("does a global ban if no room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userBan(
|
|
"testUserId",
|
|
for: nil,
|
|
from: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserBanRequest = try! JSONDecoder().decode(OpenGroupAPI.UserBanRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beTrue())
|
|
expect(requestBody.rooms).to(beNil())
|
|
}
|
|
|
|
it("does room specific bans if room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userBan(
|
|
"testUserId",
|
|
for: nil,
|
|
from: ["testRoom"],
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserBanRequest = try! JSONDecoder().decode(OpenGroupAPI.UserBanRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beNil())
|
|
expect(requestBody.rooms).to(equal(["testRoom"]))
|
|
}
|
|
}
|
|
|
|
context("when unbanning a user") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
response = nil
|
|
}
|
|
|
|
it("generates the request and handles the response correctly") {
|
|
OpenGroupAPI
|
|
.userUnban(
|
|
"testUserId",
|
|
from: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/user/testUserId/unban"))
|
|
}
|
|
|
|
it("does a global ban if no room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userUnban(
|
|
"testUserId",
|
|
from: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserUnbanRequest = try! JSONDecoder().decode(OpenGroupAPI.UserUnbanRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beTrue())
|
|
expect(requestBody.rooms).to(beNil())
|
|
}
|
|
|
|
it("does room specific bans if room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userUnban(
|
|
"testUserId",
|
|
from: ["testRoom"],
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserUnbanRequest = try! JSONDecoder().decode(OpenGroupAPI.UserUnbanRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beNil())
|
|
expect(requestBody.rooms).to(equal(["testRoom"]))
|
|
}
|
|
}
|
|
|
|
context("when updating a users permissions") {
|
|
var response: (info: OnionRequestResponseInfoType, data: Data?)?
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? { return Data() }
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
response = nil
|
|
}
|
|
|
|
it("generates the request and handles the response correctly") {
|
|
OpenGroupAPI
|
|
.userModeratorUpdate(
|
|
"testUserId",
|
|
moderator: true,
|
|
admin: nil,
|
|
visible: true,
|
|
for: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/user/testUserId/moderator"))
|
|
}
|
|
|
|
it("does a global update if no room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userModeratorUpdate(
|
|
"testUserId",
|
|
moderator: true,
|
|
admin: nil,
|
|
visible: true,
|
|
for: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserModeratorRequest = try! JSONDecoder().decode(OpenGroupAPI.UserModeratorRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beTrue())
|
|
expect(requestBody.rooms).to(beNil())
|
|
}
|
|
|
|
it("does room specific updates if room tokens are provided") {
|
|
OpenGroupAPI
|
|
.userModeratorUpdate(
|
|
"testUserId",
|
|
moderator: true,
|
|
admin: nil,
|
|
visible: true,
|
|
for: ["testRoom"],
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.info as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let requestBody: OpenGroupAPI.UserModeratorRequest = try! JSONDecoder().decode(OpenGroupAPI.UserModeratorRequest.self, from: requestData!.body!)
|
|
|
|
expect(requestBody.global).to(beNil())
|
|
expect(requestBody.rooms).to(equal(["testRoom"]))
|
|
}
|
|
|
|
it("fails if neither moderator or admin are set") {
|
|
OpenGroupAPI
|
|
.userModeratorUpdate(
|
|
"testUserId",
|
|
moderator: nil,
|
|
admin: nil,
|
|
visible: true,
|
|
for: nil,
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(HTTP.Error.generic.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
|
|
context("when banning and deleting all messages for a user") {
|
|
var response: [OnionRequestResponseInfoType]?
|
|
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
let responses: [Data] = [
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse<NoResponse>(
|
|
code: 200,
|
|
headers: [:],
|
|
body: nil,
|
|
failedToParseBody: false
|
|
)
|
|
),
|
|
try! JSONEncoder().encode(
|
|
OpenGroupAPI.BatchSubResponse<NoResponse>(
|
|
code: 200,
|
|
headers: [:],
|
|
body: nil,
|
|
failedToParseBody: false
|
|
)
|
|
)
|
|
]
|
|
|
|
return "[\(responses.map { String(data: $0, encoding: .utf8)! }.joined(separator: ","))]".data(using: .utf8)
|
|
}
|
|
}
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
afterEach {
|
|
response = nil
|
|
}
|
|
|
|
it("generates the request and handles the response correctly") {
|
|
OpenGroupAPI
|
|
.userBanAndDeleteAllMessages(
|
|
"testUserId",
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.first as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.httpMethod).to(equal("POST"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.urlString).to(equal("testServer/sequence"))
|
|
}
|
|
|
|
it("bans the user from the specified room rather than globally") {
|
|
OpenGroupAPI
|
|
.userBanAndDeleteAllMessages(
|
|
"testUserId",
|
|
in: "testRoom",
|
|
on: "testServer",
|
|
using: dependencies
|
|
)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate request data
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.first as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
let jsonObject: Any = try! JSONSerialization.jsonObject(
|
|
with: requestData!.body!,
|
|
options: [.fragmentsAllowed]
|
|
)
|
|
let firstJsonObject: Any = ((jsonObject as! [Any]).first as! [String: Any])["json"]!
|
|
let firstJsonData: Data = try! JSONSerialization.data(withJSONObject: firstJsonObject)
|
|
let firstRequestBody: OpenGroupAPI.UserBanRequest = try! JSONDecoder()
|
|
.decode(OpenGroupAPI.UserBanRequest.self, from: firstJsonData)
|
|
|
|
expect(firstRequestBody.global).to(beNil())
|
|
expect(firstRequestBody.rooms).to(equal(["testRoom"]))
|
|
}
|
|
}
|
|
|
|
// MARK: - Authentication
|
|
|
|
context("when signing") {
|
|
beforeEach {
|
|
class TestApi: TestOnionRequestAPI {
|
|
override class var mockResponse: Data? {
|
|
return try! JSONEncoder().encode([OpenGroupAPI.Room]())
|
|
}
|
|
}
|
|
|
|
dependencies = dependencies.with(onionApi: TestApi.self)
|
|
}
|
|
|
|
it("fails when there is no userEdKeyPair") {
|
|
mockStorage.when { $0.getUserED25519KeyPair() }.thenReturn(nil)
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails when there is no serverPublicKey") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn(nil)
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.noPublicKey.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails when the serverPublicKey is not a hex string") {
|
|
mockStorage.when { $0.getOpenGroupPublicKey(for: any()) }.thenReturn("TestString!!!")
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
context("when unblinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs correctly") {
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.urlString).to(equal("testServer/rooms"))
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.publicKey).to(equal("7aecdcade88d881d2327ab011afd2e04c2ec6acffc9e9df45aaf78a151bd2f7d"))
|
|
expect(requestData?.headers).to(haveCount(4))
|
|
expect(requestData?.headers[Header.sogsPubKey.rawValue])
|
|
.to(equal("007aecdcade88d881d2327ab011afd2e04c2ec6acffc9e9df45aaf78a151bd2f7d"))
|
|
expect(requestData?.headers[Header.sogsTimestamp.rawValue]).to(equal("1234567890"))
|
|
expect(requestData?.headers[Header.sogsNonce.rawValue]).to(equal("pK6YRtQApl4NhECGizF0Cg=="))
|
|
expect(requestData?.headers[Header.sogsSignature.rawValue]).to(equal("TestSignature".bytes.toBase64()))
|
|
}
|
|
|
|
it("fails when the signature is not generated") {
|
|
mockSign.when { $0.signature(message: any(), secretKey: any()) }.thenReturn(nil)
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
|
|
context("when blinded") {
|
|
beforeEach {
|
|
mockStorage
|
|
.when { $0.getOpenGroupServer(name: any()) }
|
|
.thenReturn(
|
|
OpenGroupAPI.Server(
|
|
name: "testServer",
|
|
capabilities: OpenGroupAPI.Capabilities(capabilities: [.sogs, .blind], missing: [])
|
|
)
|
|
)
|
|
}
|
|
|
|
it("signs correctly") {
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(response)
|
|
.toEventuallyNot(
|
|
beNil(),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
expect(error?.localizedDescription).to(beNil())
|
|
|
|
// Validate signature headers
|
|
let requestData: TestOnionRequestAPI.RequestData? = (response?.0 as? TestOnionRequestAPI.ResponseInfo)?.requestData
|
|
expect(requestData?.urlString).to(equal("testServer/rooms"))
|
|
expect(requestData?.httpMethod).to(equal("GET"))
|
|
expect(requestData?.server).to(equal("testServer"))
|
|
expect(requestData?.publicKey).to(equal("7aecdcade88d881d2327ab011afd2e04c2ec6acffc9e9df45aaf78a151bd2f7d"))
|
|
expect(requestData?.headers).to(haveCount(4))
|
|
expect(requestData?.headers[Header.sogsPubKey.rawValue]).to(equal("157aecdcade88d881d2327ab011afd2e04c2ec6acffc9e9df45aaf78a151bd2f7d"))
|
|
expect(requestData?.headers[Header.sogsTimestamp.rawValue]).to(equal("1234567890"))
|
|
expect(requestData?.headers[Header.sogsNonce.rawValue]).to(equal("pK6YRtQApl4NhECGizF0Cg=="))
|
|
expect(requestData?.headers[Header.sogsSignature.rawValue]).to(equal("TestSogsSignature".bytes.toBase64()))
|
|
}
|
|
|
|
it("fails when the blindedKeyPair is not generated") {
|
|
mockSodium
|
|
.when { $0.blindedKeyPair(serverPublicKey: any(), edKeyPair: any(), genericHash: mockGenericHash) }
|
|
.thenReturn(nil)
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
|
|
it("fails when the sogsSignature is not generated") {
|
|
mockSodium
|
|
.when { $0.blindedKeyPair(serverPublicKey: any(), edKeyPair: any(), genericHash: mockGenericHash) }
|
|
.thenReturn(nil)
|
|
|
|
OpenGroupAPI.rooms(for: "testServer", using: dependencies)
|
|
.get { result in response = result }
|
|
.catch { requestError in error = requestError }
|
|
.retainUntilComplete()
|
|
|
|
expect(error?.localizedDescription)
|
|
.toEventually(
|
|
equal(OpenGroupAPI.Error.signingFailed.localizedDescription),
|
|
timeout: .milliseconds(100)
|
|
)
|
|
|
|
expect(response).to(beNil())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|