Quelle  UnreadMessagesTests.swift   Sprache: JAVA

import CoreData
import ThreemaEssentials
import XCTest

@testable import ThreemaFramework

final class UnreadMessagesTests: XCTestCase {
    
    private var testDatabase: TestDatabase!

    private var testDataConversation1: ConversationEntity!
    private var testDataConversation2: ConversationEntity!
    private var testDataConversation3: ConversationEntity!

    override func setUpWithError() throws {
        AppGroup.setGroupID("group.ch.threema") // THREEMA_GROUP_IDENTIFIER @"group.ch.threema"

        testDatabase = TestDatabase()

        // Setup DB for testing
        let dp = testDatabase.preparer
        dp.save {
            let contact1 = dp.createContact(
                publicKey: BytesUtility.generateRandomBytes(length: 32)!,
                identity: "TESTER01"
            )
            self.testDataConversation1 = dp
                .createConversation(typing: false, unreadMessageCount: 2, visibility: .default) { conversation in
                    dp.createTextMessage(
                        conversation: conversation,
                        text: "msg1",
                        date: Date(),
                        delivered: true,
                        id: BytesUtility.generateRandomBytes(length: ThreemaProtocol.messageIDLength)!,
                        isOwn: false,
                        read: false,
                        sent: true,
                        userack: false,
                        sender: contact1,
                        remoteSentDate: Date(timeIntervalSinceNow: -100)
                    )
                }

            let contact2 = dp.createContact(
                publicKey: BytesUtility.generateRandomBytes(length: 32)!,
                identity: "TESTER02"
            )
            self.testDataConversation2 = dp
                .createConversation(typing: false, unreadMessageCount: 3, visibility: .default) { conversation in
                    dp.createTextMessage(
                        conversation: conversation,
                        text: "msg1",
                        date: Date(),
                        delivered: true,
                        id: BytesUtility.generateRandomBytes(length: ThreemaProtocol.messageIDLength)!,
                        isOwn: false,
                        read: false,
                        sent: true,
                        userack: false,
                        sender: contact2,
                        remoteSentDate: Date(timeIntervalSinceNow: -100)
                    )
                    dp.createTextMessage(
                        conversation: conversation,
                        text: "msg2",
                        date: Date(),
                        delivered: true,
                        id: BytesUtility.generateRandomBytes(length: ThreemaProtocol.messageIDLength)!,
                        isOwn: false,
                        read: false,
                        sent: true,
                        userack: false,
                        sender: contact2,
                        remoteSentDate: Date(timeIntervalSinceNow: -100)
                    )
                    dp.createTextMessage(
                        conversation: conversation,
                        text: "msg3",
                        date: Date(),
                        delivered: true,
                        id: BytesUtility.generateRandomBytes(length: ThreemaProtocol.messageIDLength)!,
                        isOwn: false,
                        read: true,
                        sent: true,
                        userack: false,
                        sender: contact2,
                        remoteSentDate: Date(timeIntervalSinceNow: -100)
                    )
                }

            let contact3 = dp.createContact(
                publicKey: BytesUtility.generateRandomBytes(length: 32)!,
                identity: "TESTER03"
            )
            self.testDataConversation3 = dp
                .createConversation(typing: false, unreadMessageCount: -1, visibility: .default) { conversation in
                    dp.createTextMessage(
                        conversation: conversation,
                        text: "msg1",
                        date: Date(),
                        delivered: true,
                        id: BytesUtility.generateRandomBytes(length: ThreemaProtocol.messageIDLength)!,
                        isOwn: false,
                        read: true,
                        sent: true,
                        userack: false,
                        sender: contact3,
                        remoteSentDate: Date(timeIntervalSinceNow: -100)
                    )
                }
        }
    }

    func testTotalCount() throws {
        let unreadMessages = UnreadMessages(
            messageSender: MessageSenderMock(),
            entityManager: testDatabase.entityManager
        )
        let count = unreadMessages.totalCount()
        
        XCTAssertEqual(count, 6)
    }

    func testTotalCountWithRecalculateConversation1() throws {
        let unreadMessages = UnreadMessages(
            messageSender: MessageSenderMock(),
            entityManager: testDatabase.entityManager
        )
        let count = unreadMessages.totalCount(doCalcUnreadMessagesCountOf: [testDataConversation1])

        XCTAssertEqual(count, 5)
        XCTAssertEqual(testDataConversation1.unreadMessageCount, 1)
    }

    func testTotalCountWithRecalculateAllConversations() throws {
        let unreadMessages = UnreadMessages(
            messageSender: MessageSenderMock(),
            entityManager: testDatabase.entityManager
        )
        let count = unreadMessages
            .totalCount(doCalcUnreadMessagesCountOf: [
                testDataConversation1,
                testDataConversation2,
                testDataConversation3,
            ])

        XCTAssertEqual(count, 4)
        XCTAssertEqual(testDataConversation1.unreadMessageCount, 1)
        XCTAssertEqual(testDataConversation2.unreadMessageCount, 2)
        XCTAssertEqual(testDataConversation3.unreadMessageCount, -1)
    }

    func testCountWithRecalculateConversation1() throws {
        let unreadMessages = UnreadMessages(
            messageSender: MessageSenderMock(),
            entityManager: testDatabase.entityManager
        )
        let count = unreadMessages.count(for: testDataConversation1)

        XCTAssertEqual(count, 1)
        XCTAssertEqual(testDataConversation1.unreadMessageCount, 1)
    }
}