// Copyright © 2023 Rangeproof Pty Ltd. All rights reserved.

import Foundation
import GRDB
import Sodium
import SessionUtil
import SessionUtilitiesKit

import Quick
import Nimble

@testable import SessionSnodeKit
@testable import SessionMessagingKit

class SessionUtilSpec: QuickSpec {
    override class func spec() {
        // MARK: Configuration
        
        @TestState var dependencies: TestDependencies! = TestDependencies { dependencies in
            dependencies.dateNow = Date(timeIntervalSince1970: 1234567890)
            dependencies.forceSynchronous = true
            dependencies.setMockableValue(JSONEncoder.OutputFormatting.sortedKeys)  // Deterministic ordering
        }
        @TestState(cache: .general, in: dependencies) var mockGeneralCache: MockGeneralCache! = MockGeneralCache(
            initialSetup: { cache in
                cache.when { $0.sessionId }.thenReturn(SessionId(.standard, hex: TestConstants.publicKey))
            }
        )
        @TestState(singleton: .storage, in: dependencies) var mockStorage: Storage! = SynchronousStorage(
            customWriter: try! DatabaseQueue(),
            migrationTargets: [
                SNUtilitiesKit.self,
                SNMessagingKit.self
            ],
            using: dependencies,
            initialData: { db in
                try Identity(variant: .x25519PublicKey, data: Data(hex: TestConstants.publicKey)).insert(db)
                try Identity(variant: .x25519PrivateKey, data: Data(hex: TestConstants.privateKey)).insert(db)
                try Identity(variant: .ed25519PublicKey, data: Data(hex: TestConstants.edPublicKey)).insert(db)
                try Identity(variant: .ed25519SecretKey, data: Data(hex: TestConstants.edSecretKey)).insert(db)
            }
        )
        @TestState(singleton: .crypto, in: dependencies) var mockCrypto: MockCrypto! = MockCrypto(
            initialSetup: { crypto in
                crypto
                    .when { $0.generate(.ed25519KeyPair(seed: .any, using: .any)) }
                    .thenReturn(
                        KeyPair(
                            publicKey: Data.data(
                                fromHex: "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                            )!.bytes,
                            secretKey: Data.data(
                                fromHex: "0123456789abcdef0123456789abcdeffedcba9876543210fedcba9876543210" +
                                "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                            )!.bytes
                        )
                    )
                crypto
                    .when { try $0.tryGenerate(.signature(message: .any, secretKey: .any)) }
                    .thenReturn(
                        Authentication.Signature.standard(signature: Array("TestSignature".data(using: .utf8)!))
                    )
            }
        )
        @TestState(singleton: .network, in: dependencies) var mockNetwork: MockNetwork! = MockNetwork(
            initialSetup: { network in
                network
                    .when { $0.send(.selectedNetworkRequest(.any, to: .any, timeout: .any, using: .any)) }
                    .thenReturn(MockNetwork.response(data: Data([1, 2, 3])))
            }
        )
        @TestState(singleton: .jobRunner, in: dependencies) var mockJobRunner: MockJobRunner! = MockJobRunner(
            initialSetup: { jobRunner in
                jobRunner
                    .when { $0.add(.any, job: .any, dependantJob: .any, canStartJob: .any, using: .any) }
                    .thenReturn(nil)
            }
        )
        @TestState(defaults: .standard, in: dependencies) var mockUserDefaults: MockUserDefaults! = MockUserDefaults(
            initialSetup: { userDefaults in
                userDefaults.when { $0.string(forKey: .any) }.thenReturn(nil)
            }
        )
        
        @TestState var createGroupOutput: SessionUtil.CreatedGroupInfo! = {
            mockStorage.write(using: dependencies) { db in
                 try SessionUtil.createGroup(
                    db,
                    name: "TestGroup",
                    description: nil,
                    displayPictureUrl: nil,
                    displayPictureFilename: nil,
                    displayPictureEncryptionKey: nil,
                    members: [],
                    using: dependencies
                 )
            }
        }()
        @TestState var mockSwarmCache: Set<Snode>! = [
            Snode(
                address: "test",
                port: 0,
                ed25519PublicKey: TestConstants.edPublicKey,
                x25519PublicKey: TestConstants.publicKey
            ),
            Snode(
                address: "test",
                port: 1,
                ed25519PublicKey: TestConstants.edPublicKey,
                x25519PublicKey: TestConstants.publicKey
            ),
            Snode(
                address: "test",
                port: 2,
                ed25519PublicKey: TestConstants.edPublicKey,
                x25519PublicKey: TestConstants.publicKey
            )
        ]
        @TestState(cache: .snodeAPI, in: dependencies) var mockSnodeAPICache: MockSnodeAPICache! = MockSnodeAPICache(
            initialSetup: { cache in
                cache.when { $0.clockOffsetMs }.thenReturn(0)
                cache.when { $0.loadedSwarms }.thenReturn([createGroupOutput.groupSessionId.hexString])
                cache.when { $0.swarmCache }.thenReturn([createGroupOutput.groupSessionId.hexString: mockSwarmCache])
            }
        )
        @TestState(cache: .sessionUtil, in: dependencies) var mockSessionUtilCache: MockSessionUtilCache! = MockSessionUtilCache(
            initialSetup: { cache in
                var conf: UnsafeMutablePointer<config_object>!
                var secretKey: [UInt8] = Array(Data(hex: TestConstants.edSecretKey))
                _ = user_groups_init(&conf, &secretKey, nil, 0, nil)
                
                cache.when { $0.setConfig(for: .any, sessionId: .any, to: .any) }.thenReturn(())
                cache.when { $0.config(for: .userGroups, sessionId: .any) }
                    .thenReturn(Atomic(.object(conf)))
                cache.when { $0.config(for: .groupInfo, sessionId: .any) }
                    .thenReturn(Atomic(createGroupOutput.groupState[.groupInfo]))
                cache.when { $0.config(for: .groupMembers, sessionId: .any) }
                    .thenReturn(Atomic(createGroupOutput.groupState[.groupMembers]))
                cache.when { $0.config(for: .groupKeys, sessionId: .any) }
                    .thenReturn(Atomic(createGroupOutput.groupState[.groupKeys]))
            }
        )
        @TestState var userGroupsConfig: SessionUtil.Config!
        
        // MARK: - SessionUtil
        describe("SessionUtil") {
            // MARK: -- when parsing a community url
            context("when parsing a community url") {
                // MARK: ---- handles the example urls correctly
                it("handles the example urls correctly") {
                    let validUrls: [String] = [
                        [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "https://sessionopengroup.co/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "http://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "http://sessionopengroup.co/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "https://143.198.213.225:443/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "https://143.198.213.225:443/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "http://143.198.213.255:80/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ],
                        [
                            "http://143.198.213.255:80/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ]
                    ].map { $0.joined() }
                    let processedValues: [(room: String, server: String, publicKey: String)] = validUrls
                        .map { SessionUtil.parseCommunity(url: $0) }
                        .compactMap { $0 }
                    let processedRooms: [String] = processedValues.map { $0.room }
                    let processedServers: [String] = processedValues.map { $0.server }
                    let processedPublicKeys: [String] = processedValues.map { $0.publicKey }
                    let expectedRooms: [String] = [String](repeating: "main", count: 8)
                    let expectedServers: [String] = [
                        "https://sessionopengroup.co",
                        "https://sessionopengroup.co",
                        "http://sessionopengroup.co",
                        "http://sessionopengroup.co",
                        "https://143.198.213.225",
                        "https://143.198.213.225",
                        "http://143.198.213.255",
                        "http://143.198.213.255"
                    ]
                    let expectedPublicKeys: [String] = [String](
                        repeating: "658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c",
                        count: 8
                    )
                    
                    expect(processedValues.count).to(equal(validUrls.count))
                    expect(processedRooms).to(equal(expectedRooms))
                    expect(processedServers).to(equal(expectedServers))
                    expect(processedPublicKeys).to(equal(expectedPublicKeys))
                }

                // MARK: ---- handles the r prefix if present
                it("handles the r prefix if present") {
                    let info = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )
                    
                    expect(info?.room).to(equal("main"))
                    expect(info?.server).to(equal("https://sessionopengroup.co"))
                    expect(info?.publicKey).to(equal("658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"))
                }

                // MARK: ---- fails if no scheme is provided
                it("fails if no scheme is provided") {
                    let info = SessionUtil.parseCommunity(
                        url: [
                            "sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )
                    
                    expect(info?.room).to(beNil())
                    expect(info?.server).to(beNil())
                    expect(info?.publicKey).to(beNil())
                }
                
                // MARK: ---- fails if there is no room
                it("fails if there is no room") {
                    let info = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )
                    
                    expect(info?.room).to(beNil())
                    expect(info?.server).to(beNil())
                    expect(info?.publicKey).to(beNil())
                }
                
                // MARK: ---- fails if there is no public key parameter
                it("fails if there is no public key parameter") {
                    let info = SessionUtil.parseCommunity(
                        url: "https://sessionopengroup.co/r/main"
                    )
                    
                    expect(info?.room).to(beNil())
                    expect(info?.server).to(beNil())
                    expect(info?.publicKey).to(beNil())
                }
                
                // MARK: ---- fails if the public key parameter is not 64 characters
                it("fails if the public key parameter is not 64 characters") {
                    let info = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231"
                        ].joined()
                    )
                    
                    expect(info?.room).to(beNil())
                    expect(info?.server).to(beNil())
                    expect(info?.publicKey).to(beNil())
                }
                
                // MARK: ---- fails if the public key parameter is not a hex string
                it("fails if the public key parameter is not a hex string") {
                    let info = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
                        ].joined()
                    )
                    
                    expect(info?.room).to(beNil())
                    expect(info?.server).to(beNil())
                    expect(info?.publicKey).to(beNil())
                }
                
                // MARK: ---- maintains the same TLS
                it("maintains the same TLS") {
                    let server1 = SessionUtil.parseCommunity(
                        url: [
                            "http://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )?.server
                    let server2 = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )?.server
                    
                    expect(server1).to(equal("http://sessionopengroup.co"))
                    expect(server2).to(equal("https://sessionopengroup.co"))
                }
                
                // MARK: ---- maintains the same port
                it("maintains the same port") {
                    let server1 = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )?.server
                    let server2 = SessionUtil.parseCommunity(
                        url: [
                            "https://sessionopengroup.co:1234/r/main?",
                            "public_key=658d29b91892a2389505596b135e76a53db6e11d613a51dbd3d0816adffb231c"
                        ].joined()
                    )?.server
                    
                    expect(server1).to(equal("https://sessionopengroup.co"))
                    expect(server2).to(equal("https://sessionopengroup.co:1234"))
                }
            }
            
            // MARK: -- when generating a url
            context("when generating a url") {
                // MARK: ---- generates the url correctly
                it("generates the url correctly") {
                    expect(SessionUtil.communityUrlFor(server: "server", roomToken: "room", publicKey: "f8fec9b701000000ffffffff0400008000000000000000000000000000000000"))
                        .to(equal("server/room?public_key=f8fec9b701000000ffffffff0400008000000000000000000000000000000000"))
                }
                
                // MARK: ---- maintains the casing provided
                it("maintains the casing provided") {
                    expect(SessionUtil.communityUrlFor(server: "SeRVer", roomToken: "RoOM", publicKey: "f8fec9b701000000ffffffff0400008000000000000000000000000000000000"))
                        .to(equal("SeRVer/RoOM?public_key=f8fec9b701000000ffffffff0400008000000000000000000000000000000000"))
                }
            }
            
            // MARK: -- when creating a group
            context("when creating a group") {
                beforeEach {
                    var userGroupsConf: UnsafeMutablePointer<config_object>!
                    var secretKey: [UInt8] = Array(Data(hex: TestConstants.edSecretKey))
                    _ = user_groups_init(&userGroupsConf, &secretKey, nil, 0, nil)
                    userGroupsConfig = .object(userGroupsConf)
                    
                    mockSessionUtilCache
                        .when { $0.config(for: .userGroups, sessionId: .any) }
                        .thenReturn(Atomic(userGroupsConfig))
                }
                
                // MARK: ---- throws when there is no user ed25519 keyPair
                it("throws when there is no user ed25519 keyPair") {
                    var resultError: Error? = nil
                    
                    mockStorage.write { db in
                        try Identity.filter(id: .ed25519PublicKey).deleteAll(db)
                        try Identity.filter(id: .ed25519SecretKey).deleteAll(db)
                        
                        do {
                            _ = try SessionUtil.createGroup(
                                db,
                                name: "Testname",
                                description: nil,
                                displayPictureUrl: nil,
                                displayPictureFilename: nil,
                                displayPictureEncryptionKey: nil,
                                members: [],
                                using: dependencies
                            )
                        }
                        catch { resultError = error }
                    }
                    
                    expect(resultError).to(matchError(MessageSenderError.noKeyPair))
                }
                
                // MARK: ---- throws when it fails to generate a new identity ed25519 keyPair
                it("throws when it fails to generate a new identity ed25519 keyPair") {
                    var resultError: Error? = nil
                    
                    mockCrypto
                        .when { $0.generate(.ed25519KeyPair(seed: .any, using: .any)) }
                        .thenReturn(nil)
                    
                    mockStorage.write { db in
                        do {
                            _ = try SessionUtil.createGroup(
                                db,
                                name: "Testname",
                                description: nil,
                                displayPictureUrl: nil,
                                displayPictureFilename: nil,
                                displayPictureEncryptionKey: nil,
                                members: [],
                                using: dependencies
                            )
                        }
                        catch { resultError = error }
                    }
                    
                    expect(resultError).to(matchError(MessageSenderError.noKeyPair))
                }
                
                // MARK: ---- throws when given an invalid member id
                it("throws when given an invalid member id") {
                    var resultError: Error? = nil
                    
                    mockStorage.write { db in
                        do {
                            _ = try SessionUtil.createGroup(
                                db,
                                name: "Testname",
                                description: nil,
                                displayPictureUrl: nil,
                                displayPictureFilename: nil,
                                displayPictureEncryptionKey: nil,
                                members: [(
                                    id: "123456",
                                    profile: Profile(
                                        id: "123456",
                                        name: ""
                                    )
                                )],
                                using: dependencies
                            )
                        }
                        catch { resultError = error }
                    }
                    
                    expect(resultError).to(matchError(
                        NSError(
                            domain: "cpp_exception",
                            code: -2,
                            userInfo: [
                                NSLocalizedDescriptionKey: "Invalid session ID: expected 66 hex digits starting with 05; got 123456"
                            ]
                        )
                    ))
                }
                
                // MARK: ---- returns the correct identity keyPair
                it("returns the correct identity keyPair") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [],
                            using: dependencies
                        )
                    }
                    
                    expect(createGroupOutput.identityKeyPair.publicKey.toHexString())
                        .to(equal("cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"))
                    expect(createGroupOutput.identityKeyPair.secretKey.toHexString())
                        .to(equal(
                            "0123456789abcdef0123456789abcdeffedcba9876543210fedcba9876543210" +
                            "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                        ))
                }
                
                // MARK: ---- returns a closed group with the correct data set
                it("returns a closed group with the correct data set") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: "TestUrl",
                            displayPictureFilename: "TestFilename",
                            displayPictureEncryptionKey: Data([1, 2, 3]),
                            members: [],
                            using: dependencies
                        )
                    }
                    
                    expect(createGroupOutput.group.threadId)
                        .to(equal("03cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"))
                    expect(createGroupOutput.group.groupIdentityPrivateKey?.toHexString())
                        .to(equal(
                            "0123456789abcdef0123456789abcdeffedcba9876543210fedcba9876543210" +
                            "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                        ))
                    expect(createGroupOutput.group.name).to(equal("Testname"))
                    expect(createGroupOutput.group.displayPictureUrl).to(equal("TestUrl"))
                    expect(createGroupOutput.group.displayPictureFilename).to(equal("TestFilename"))
                    expect(createGroupOutput.group.displayPictureEncryptionKey).to(equal(Data([1, 2, 3])))
                    expect(createGroupOutput.group.formationTimestamp).to(equal(1234567890))
                    expect(createGroupOutput.group.invited).to(beFalse())
                }
                
                // MARK: ---- returns the members setup correctly
                it("returns the members setup correctly") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: Profile(
                                    id: "051111111111111111111111111111111111111111111111111111111111111111",
                                    name: "TestName",
                                    profilePictureUrl: "testUrl",
                                    profileEncryptionKey: Data([1, 2, 3])
                                )
                            )],
                            using: dependencies
                        )
                    }
                    
                    expect(createGroupOutput.members.count).to(equal(2))
                    expect(createGroupOutput.members.map { $0.groupId })
                        .to(equal([
                            "03cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece",
                            "03cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece",
                        ]))
                    expect(createGroupOutput.members.map { $0.profileId }.asSet())
                        .to(equal([
                            "051111111111111111111111111111111111111111111111111111111111111111",
                            "05\(TestConstants.publicKey)"
                        ]))
                    expect(createGroupOutput.members.map { $0.role }.asSet())
                        .to(equal([
                            .standard,
                            .admin
                        ]))
                    expect(createGroupOutput.members.map { $0.isHidden }.asSet())
                        .to(equal([
                            false,
                            false
                        ]))
                }
                
                // MARK: ---- adds the current user as an admin when not provided
                it("adds the current user as an admin when not provided") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: Profile(
                                    id: "051111111111111111111111111111111111111111111111111111111111111111",
                                    name: "TestName"
                                )
                            )],
                            using: dependencies
                        )
                    }
                    
                    expect(createGroupOutput.members.map { $0.groupId })
                        .to(contain("03cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"))
                    expect(createGroupOutput.members.map { $0.profileId })
                        .to(contain("05\(TestConstants.publicKey)"))
                    expect(createGroupOutput.members.map { $0.role }).to(contain(.admin))
                }
                
                // MARK: ---- handles members without profile data correctly
                it("handles members without profile data correctly") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: nil
                            )],
                            using: dependencies
                        )
                    }
                    
                    expect(createGroupOutput.members.count).to(equal(2))
                    expect(createGroupOutput.members.map { $0.groupId })
                        .to(contain("03cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"))
                    expect(createGroupOutput.members.map { $0.profileId })
                        .to(contain("051111111111111111111111111111111111111111111111111111111111111111"))
                    expect(createGroupOutput.members.map { $0.role }).to(contain(.standard))
                }
                
                // MARK: ---- stores the config states in the cache correctly
                it("stores the config states in the cache correctly") {
                    createGroupOutput = mockStorage.write(using: dependencies) { db in
                        try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: nil
                            )],
                            using: dependencies
                        )
                    }
                    
                    expect(mockSessionUtilCache).to(call(.exactly(times: 3)) {
                        $0.setConfig(for: .any, sessionId: .any, to: .any)
                    })
                    expect(mockSessionUtilCache)
                        .to(call(matchingParameters: .atLeast(2)) {
                            $0.setConfig(
                                for: .groupInfo,
                                sessionId: SessionId(
                                    .group,
                                    hex: "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                                ),
                                to: .any
                            )
                        })
                    expect(mockSessionUtilCache)
                        .to(call(matchingParameters: .atLeast(2)) {
                            $0.setConfig(
                                for: .groupMembers,
                                sessionId: SessionId(
                                    .group,
                                    hex: "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                                ),
                                to: .any
                            )
                        })
                    expect(mockSessionUtilCache)
                        .to(call(matchingParameters: .atLeast(2)) {
                            $0.setConfig(
                                for: .groupKeys,
                                sessionId: SessionId(
                                    .group,
                                    hex: "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                                ),
                                to: .any
                            )
                        })
                }
            }
            
            // MARK: -- when saving a created a group
            context("when saving a created a group") {
                // MARK: ---- saves config dumps for the stored configs
                it("saves config dumps for the stored configs") {
                    mockStorage.write(using: dependencies) { db in
                        createGroupOutput = try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: nil
                            )],
                            using: dependencies
                        )
                        
                        try SessionUtil.saveCreatedGroup(
                            db,
                            group: createGroupOutput.group,
                            groupState: createGroupOutput.groupState,
                            using: dependencies
                        )
                    }
                    
                    let result: [ConfigDump]? = mockStorage.read(using: dependencies) { db in
                        try ConfigDump.fetchAll(db)
                    }
                    
                    expect(result?.map { $0.variant }.asSet())
                        .to(contain([.groupInfo, .groupKeys, .groupMembers]))
                    expect(result?.map { $0.sessionId }.asSet())
                        .to(contain([
                            SessionId(
                                .group,
                                hex: "cbd569f56fb13ea95a3f0c05c331cc24139c0090feb412069dc49fab34406ece"
                            )
                        ]))
                    expect(result?.map { $0.timestampMs }.asSet())
                        .to(contain([1234567890000]))
                }
                
                // MARK: ---- adds the group to the user groups config
                it("adds the group to the user groups config") {
                    mockStorage.write(using: dependencies) { db in
                        createGroupOutput = try SessionUtil.createGroup(
                            db,
                            name: "Testname",
                            description: nil,
                            displayPictureUrl: nil,
                            displayPictureFilename: nil,
                            displayPictureEncryptionKey: nil,
                            members: [(
                                id: "051111111111111111111111111111111111111111111111111111111111111111",
                                profile: nil
                            )],
                            using: dependencies
                        )
                        
                        try SessionUtil.saveCreatedGroup(
                            db,
                            group: createGroupOutput.group,
                            groupState: createGroupOutput.groupState,
                            using: dependencies
                        )
                    }
                    
                    let result: [ConfigDump]? = mockStorage.read(using: dependencies) { db in
                        try ConfigDump.fetchAll(db)
                    }
                    
                    expect(result?.map { $0.variant }.asSet()).to(contain([.userGroups]))
                    expect(result?.map { $0.timestampMs }.asSet()).to(contain([1234567890000]))
                }
            }
            
            // MARK: -- when receiving a GROUP_INFO update
            context("when receiving a GROUP_INFO update") {
                @TestState var latestGroup: ClosedGroup?
                @TestState var initialDisappearingConfig: DisappearingMessagesConfiguration?
                @TestState var latestDisappearingConfig: DisappearingMessagesConfiguration?
                
                beforeEach {
                    mockStorage.write(using: dependencies) { db in
                        try SessionThread.fetchOrCreate(
                            db,
                            id: createGroupOutput.group.threadId,
                            variant: .group,
                            shouldBeVisible: true,
                            calledFromConfigHandling: false,
                            using: dependencies
                        )
                        try createGroupOutput.group.insert(db)
                        try createGroupOutput.members.forEach { try $0.insert(db) }
                        initialDisappearingConfig = try DisappearingMessagesConfiguration
                            .fetchOne(db, id: createGroupOutput.group.threadId)
                            .defaulting(
                                to: DisappearingMessagesConfiguration.defaultWith(createGroupOutput.group.threadId)
                            )
                    }
                }
                
                // MARK: ---- does nothing if there are no changes
                it("does nothing if there are no changes") {
                    dependencies.setMockableValue(key: "needsDump", false)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestGroup = mockStorage.read(using: dependencies) { db in
                        try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(createGroupOutput.groupState[.groupInfo]).toNot(beNil())
                    expect(createGroupOutput.group).to(equal(latestGroup))
                }
                
                // MARK: ---- throws if the config is invalid
                it("throws if the config is invalid") {
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        expect {
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: .invalid,
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        .to(throwError())
                    }
                }
                
                // MARK: ---- removes group data if the group is destroyed
                it("removes group data if the group is destroyed") {
                    createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_destroy_group($0) }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestGroup = mockStorage.read(using: dependencies) { db in
                        try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(latestGroup?.authData).to(beNil())
                    expect(latestGroup?.groupIdentityPrivateKey).to(beNil())
                }
                
                // MARK: ---- updates the name if it changed
                it("updates the name if it changed") {
                    createGroupOutput.groupState[.groupInfo]?.conf.map {
                        var updatedName: [CChar] = "UpdatedName".cArray.nullTerminated()
                        groups_info_set_name($0, &updatedName)
                    }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestGroup = mockStorage.read(using: dependencies) { db in
                        try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(createGroupOutput.group.name).to(equal("TestGroup"))
                    expect(latestGroup?.name).to(equal("UpdatedName"))
                }
                
                // MARK: ---- updates the description if it changed
                it("updates the description if it changed") {
                    createGroupOutput.groupState[.groupInfo]?.conf.map {
                        var updatedDesc: [CChar] = "UpdatedDesc".cArray.nullTerminated()
                        groups_info_set_description($0, &updatedDesc)
                    }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestGroup = mockStorage.read(using: dependencies) { db in
                        try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(createGroupOutput.group.groupDescription).to(beNil())
                    expect(latestGroup?.groupDescription).to(equal("UpdatedDesc"))
                }
                
                // MARK: ---- updates the formation timestamp if it changed
                it("updates the formation timestamp if it changed") {
                    createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_created($0, 54321) }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestGroup = mockStorage.read(using: dependencies) { db in
                        try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(createGroupOutput.group.formationTimestamp).to(equal(1234567890))
                    expect(latestGroup?.formationTimestamp).to(equal(54321))
                }
                
                // MARK: ---- and the display picture was changed
                context("and the display picture was changed") {
                    // MARK: ------ removes the display picture
                    it("removes the display picture") {
                        mockStorage.write(using: dependencies) { db in
                            try ClosedGroup
                                .updateAll(
                                    db,
                                    ClosedGroup.Columns.displayPictureUrl.set(to: "TestUrl"),
                                    ClosedGroup.Columns.displayPictureEncryptionKey.set(to: Data([1, 2, 3])),
                                    ClosedGroup.Columns.displayPictureFilename.set(to: "TestFilename")
                                )
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        latestGroup = mockStorage.read(using: dependencies) { db in
                            try ClosedGroup.fetchOne(db, id: createGroupOutput.group.threadId)
                        }
                        expect(latestGroup?.displayPictureUrl).to(beNil())
                        expect(latestGroup?.displayPictureEncryptionKey).to(beNil())
                        expect(latestGroup?.displayPictureFilename).to(beNil())
                        expect(latestGroup?.lastDisplayPictureUpdate).to(equal(1234567891))
                    }
                    
                    // MARK: ------ schedules a display picture download job if there is a new one
                    it("schedules a display picture download job if there is a new one") {
                        createGroupOutput.groupState[.groupInfo]?.conf.map {
                            var displayPic: user_profile_pic = user_profile_pic()
                            displayPic.url = "https://www.oxen.io/file/1234".toLibSession()
                            displayPic.key = Data(
                                repeating: 1,
                                count: DisplayPictureManager.aes256KeyByteLength
                            ).toLibSession()
                            groups_info_set_pic($0, displayPic)
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        expect(mockJobRunner)
                            .to(call(.exactly(times: 1), matchingParameters: .all) { jobRunner in
                                jobRunner.add(
                                    .any,
                                    job: Job(
                                        variant: .displayPictureDownload,
                                        behaviour: .runOnce,
                                        shouldBlock: false,
                                        shouldBeUnique: true,
                                        shouldSkipLaunchBecomeActive: false,
                                        details: DisplayPictureDownloadJob.Details(
                                            target: .group(
                                                id: createGroupOutput.group.threadId,
                                                url: "https://www.oxen.io/file/1234",
                                                encryptionKey: Data(
                                                    repeating: 1,
                                                    count: DisplayPictureManager.aes256KeyByteLength
                                                )
                                            ),
                                            timestamp: 1234567891
                                        )
                                    ),
                                    canStartJob: true,
                                    using: .any
                                )
                            })
                    }
                }
                
                // MARK: ---- updates the disappearing messages config
                it("updates the disappearing messages config") {
                    createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_expiry_timer($0, 10) }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    latestDisappearingConfig = mockStorage.read(using: dependencies) { db in
                        try DisappearingMessagesConfiguration.fetchOne(db, id: createGroupOutput.group.threadId)
                    }
                    expect(initialDisappearingConfig?.isEnabled).to(beFalse())
                    expect(initialDisappearingConfig?.durationSeconds).to(equal(0))
                    expect(latestDisappearingConfig?.isEnabled).to(beTrue())
                    expect(latestDisappearingConfig?.durationSeconds).to(equal(10))
                }
                
                // MARK: ---- containing a deleteBefore timestamp
                context("containing a deleteBefore timestamp") {
                    @TestState var numInteractions: Int!
                    
                    // MARK: ------ deletes messages before the timestamp
                    it("deletes messages before the timestamp") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            _ = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_delete_before($0, 123456) }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        numInteractions = mockStorage.read(using: dependencies) { db in
                            try Interaction.fetchCount(db)
                        }
                        expect(numInteractions).to(equal(0))
                    }
                    
                    // MARK: ------ does not delete messages after the timestamp
                    it("does not delete messages after the timestamp") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            _ = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                            _ = try Interaction(
                                serverHash: "1235",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4322",
                                variant: .standardIncoming,
                                timestampMs: 200000000
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_delete_before($0, 123456) }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        numInteractions = mockStorage.read(using: dependencies) { db in
                            try Interaction.fetchCount(db)
                        }
                        expect(numInteractions).to(equal(1))
                    }
                }
                
                // MARK: ---- containing a deleteAttachmentsBefore timestamp
                context("containing a deleteAttachmentsBefore timestamp") {
                    @TestState var numInteractions: Int!
                    
                    // MARK: ------ deletes messages with attachments before the timestamp
                    it("deletes messages with attachments before the timestamp") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            let interaction: Interaction = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                            _ = try Attachment(
                                id: "AttachmentId",
                                variant: .standard,
                                contentType: "Test",
                                byteCount: 1234
                            ).inserted(db)
                            _ = try InteractionAttachment(
                                albumIndex: 1,
                                interactionId: interaction.id!,
                                attachmentId: "AttachmentId"
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map {
                            groups_info_set_attach_delete_before($0, 123456)
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        numInteractions = mockStorage.read(using: dependencies) { db in
                            try Interaction.fetchCount(db)
                        }
                        expect(numInteractions).to(equal(0))
                    }
                    
                    // MARK: ------ schedules a garbage collection job to clean up the attachments
                    it("schedules a garbage collection job to clean up the attachments") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            let interaction: Interaction = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                            _ = try Attachment(
                                id: "AttachmentId",
                                variant: .standard,
                                contentType: "Test",
                                byteCount: 1234
                            ).inserted(db)
                            _ = try InteractionAttachment(
                                albumIndex: 1,
                                interactionId: interaction.id!,
                                attachmentId: "AttachmentId"
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map {
                            groups_info_set_attach_delete_before($0, 123456)
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        expect(mockJobRunner)
                            .to(call(.exactly(times: 1), matchingParameters: .all) { jobRunner in
                                jobRunner.add(
                                    .any,
                                    job: Job(
                                        variant: .garbageCollection,
                                        behaviour: .runOnce,
                                        shouldBlock: false,
                                        shouldBeUnique: false,
                                        shouldSkipLaunchBecomeActive: false,
                                        details: GarbageCollectionJob.Details(
                                            typesToCollect: [.orphanedAttachments, .orphanedAttachmentFiles]
                                        )
                                    ),
                                    canStartJob: true,
                                    using: .any
                                )
                            })
                    }
                    
                    // MARK: ------ does not delete messages with attachments after the timestamp
                    it("does not delete messages with attachments after the timestamp") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            let interaction1: Interaction = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                            let interaction2: Interaction = try Interaction(
                                serverHash: "1235",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 200000000
                            ).inserted(db)
                            _ = try Attachment(
                                id: "AttachmentId",
                                variant: .standard,
                                contentType: "Test",
                                byteCount: 1234
                            ).inserted(db)
                            _ = try Attachment(
                                id: "AttachmentId2",
                                variant: .standard,
                                contentType: "Test",
                                byteCount: 1234
                            ).inserted(db)
                            _ = try InteractionAttachment(
                                albumIndex: 1,
                                interactionId: interaction1.id!,
                                attachmentId: "AttachmentId"
                            ).inserted(db)
                            _ = try InteractionAttachment(
                                albumIndex: 1,
                                interactionId: interaction2.id!,
                                attachmentId: "AttachmentId2"
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map {
                            groups_info_set_attach_delete_before($0, 123456)
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        numInteractions = mockStorage.read(using: dependencies) { db in
                            try Interaction.fetchCount(db)
                        }
                        expect(numInteractions).to(equal(1))
                    }
                    
                    // MARK: ------ does not delete messages before the timestamp that have no attachments
                    it("does not delete messages before the timestamp that have no attachments") {
                        mockStorage.write(using: dependencies) { db in
                            try SessionThread.fetchOrCreate(
                                db,
                                id: createGroupOutput.group.threadId,
                                variant: .contact,
                                shouldBeVisible: true,
                                calledFromConfigHandling: false,
                                using: dependencies
                            )
                            let interaction1: Interaction = try Interaction(
                                serverHash: "1234",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 100000000
                            ).inserted(db)
                            _ = try Interaction(
                                serverHash: "1235",
                                threadId: createGroupOutput.group.threadId,
                                authorId: "4321",
                                variant: .standardIncoming,
                                timestampMs: 200000000
                            ).inserted(db)
                            _ = try Attachment(
                                id: "AttachmentId",
                                variant: .standard,
                                contentType: "Test",
                                byteCount: 1234
                            ).inserted(db)
                            _ = try InteractionAttachment(
                                albumIndex: 1,
                                interactionId: interaction1.id!,
                                attachmentId: "AttachmentId"
                            ).inserted(db)
                        }
                        
                        createGroupOutput.groupState[.groupInfo]?.conf.map {
                            groups_info_set_attach_delete_before($0, 123456)
                        }
                        dependencies.setMockableValue(key: "needsDump", true)
                        
                        mockStorage.write(using: dependencies) { db in
                            try SessionUtil.handleGroupInfoUpdate(
                                db,
                                in: createGroupOutput.groupState[.groupInfo],
                                groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                                serverTimestampMs: 1234567891000,
                                using: dependencies
                            )
                        }
                        
                        numInteractions = mockStorage.read(using: dependencies) { db in
                            try Interaction.fetchCount(db)
                        }
                        expect(numInteractions).to(equal(1))
                    }
                }
                
                // MARK: ---- deletes from the server after deleting messages before a given timestamp
                it("deletes from the server after deleting messages before a given timestamp") {
                    mockStorage.write(using: dependencies) { db in
                        try SessionThread.fetchOrCreate(
                            db,
                            id: createGroupOutput.group.threadId,
                            variant: .contact,
                            shouldBeVisible: true,
                            calledFromConfigHandling: false,
                            using: dependencies
                        )
                        _ = try Interaction(
                            serverHash: "1234",
                            threadId: createGroupOutput.group.threadId,
                            authorId: "4321",
                            variant: .standardIncoming,
                            timestampMs: 100000000
                        ).inserted(db)
                    }
                    
                    createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_delete_before($0, 123456) }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    let expectedRequest: URLRequest = try SnodeAPI
                        .preparedDeleteMessages(
                            serverHashes: ["1234"],
                            requireSuccessfulDeletion: false,
                            authMethod: Authentication.groupAdmin(
                                groupSessionId: createGroupOutput.groupSessionId,
                                ed25519SecretKey: createGroupOutput.identityKeyPair.secretKey
                            ),
                            using: dependencies
                        )
                        .request
                    expect(mockNetwork)
                        .to(call(.exactly(times: 1), matchingParameters: .all) { [dependencies = dependencies!] network in
                            network.send(
                                .selectedNetworkRequest(
                                    expectedRequest.httpBody!,
                                    to: dependencies.randomElement(mockSwarmCache)!,
                                    timeout: HTTP.defaultTimeout,
                                    using: .any
                                )
                            )
                        })
                }
                
                // MARK: ---- does not delete from the server if there is no server hash
                it("does not delete from the server if there is no server hash") {
                    mockStorage.write(using: dependencies) { db in
                        try SessionThread.fetchOrCreate(
                            db,
                            id: createGroupOutput.group.threadId,
                            variant: .contact,
                            shouldBeVisible: true,
                            calledFromConfigHandling: false,
                            using: dependencies
                        )
                        _ = try Interaction(
                            threadId: createGroupOutput.group.threadId,
                            authorId: "4321",
                            variant: .standardIncoming,
                            timestampMs: 100000000
                        ).inserted(db)
                    }
                    
                    createGroupOutput.groupState[.groupInfo]?.conf.map { groups_info_set_delete_before($0, 123456) }
                    dependencies.setMockableValue(key: "needsDump", true)
                    
                    mockStorage.write(using: dependencies) { db in
                        try SessionUtil.handleGroupInfoUpdate(
                            db,
                            in: createGroupOutput.groupState[.groupInfo],
                            groupSessionId: SessionId(.group, hex: createGroupOutput.group.threadId),
                            serverTimestampMs: 1234567891000,
                            using: dependencies
                        )
                    }
                    
                    let numInteractions: Int? = mockStorage.read(using: dependencies) { db in
                        try Interaction.fetchCount(db)
                    }
                    expect(numInteractions).to(equal(0))
                    expect(mockNetwork)
                        .toNot(call { network in
                            network.send(.selectedNetworkRequest(.any, to: .any, timeout: .any, using: .any))
                        })
                }
            }
        }
    }
}

// MARK: - Convenience

private extension SessionUtil.Config {
    var conf: UnsafeMutablePointer<config_object>? {
        switch self {
            case .object(let conf): return conf
            default: return nil
        }
    }
}