Stowage/tutanota
2
0
Fork 0
mirror of https://github.com/tutao/tutanota.git synced 2025-12-08 06:09:50 +00:00
Code Issues Projects Releases Packages Wiki Activity
tutanota/test/tests/mail/model/ConversationListModelTest.ts
sug f11e59672e
improve inbox rule handling and run spam prediction after inbox rules 
Instead of applying inbox rules based on the unread mail state in the
inbox folder, we introduce the new ProcessingState enum on
the mail type. If a mail has been processed by the leader client, which
is checking for matching inbox rules, the ProcessingState is
updated. If there is a matching rule the flag is updated through the
MoveMailService, if there is no matching rule, the flag is updated
using the ClientClassifierResultService. Both requests are
throttled / debounced. After processing inbox rules, spam prediction
is conducted for mails that have not yet been moved by an inbox rule.
The ProcessingState for not matching ham mails is also updated using
the ClientClassifierResultService.

This new inbox rule handing solves the following two problems:
 - when clicking on a notification it could still happen,
   that sometimes the inbox rules where not applied
 - when the inbox folder had a lot of unread mails, the loading time did
   massively increase, since inbox rules were re-applied on every load

Co-authored-by: amm <amm@tutao.de>
Co-authored-by: Nick <nif@tutao.de>
Co-authored-by: das <das@tutao.de>
Co-authored-by: abp <abp@tutao.de>
Co-authored-by: jhm <17314077+jomapp@users.noreply.github.com>
Co-authored-by: map <mpfau@users.noreply.github.com>
Co-authored-by: Kinan <104761667+kibibytium@users.noreply.github.com>
2025-10-22 09:40:45 +02:00

825 lines
29 KiB
TypeScript
Raw Blame History

import o from "@tutao/otest"
import {
createMailSetEntry,
Mail,
MailboxGroupRootTypeRef,
MailBoxTypeRef,
MailFolder,
MailFolderTypeRef,
MailSetEntry,
MailSetEntryTypeRef,
MailTypeRef,
} from "../../../../src/common/api/entities/tutanota/TypeRefs"
import { matchers, object, verify, when } from "testdouble"
import { ConversationPrefProvider } from "../../../../src/mail-app/mail/view/ConversationViewModel"
import { EntityClient } from "../../../../src/common/api/common/EntityClient"
import { MailModel } from "../../../../src/mail-app/mail/model/MailModel"
import { InboxRuleHandler } from "../../../../src/mail-app/mail/model/InboxRuleHandler"
import { ExposedCacheStorage } from "../../../../src/common/api/worker/rest/DefaultEntityRestCache"
import { MailSetKind, OperationType } from "../../../../src/common/api/common/TutanotaConstants"
import {
constructMailSetEntryId,
CUSTOM_MAX_ID,
CUSTOM_MIN_ID,
deconstructMailSetEntryId,
elementIdPart,
GENERATED_MAX_ID,
getElementId,
getListId,
isSameId,
listIdPart,
} from "../../../../src/common/api/common/utils/EntityUtils"
import { PageSize } from "../../../../src/common/gui/base/ListUtils"
import { createTestEntity } from "../../TestUtils"
import { EntityUpdateData, PrefetchStatus } from "../../../../src/common/api/common/utils/EntityUpdateUtils"
import { MailboxDetail } from "../../../../src/common/mailFunctionality/MailboxModel"
import { GroupInfoTypeRef, GroupTypeRef } from "../../../../src/common/api/entities/sys/TypeRefs"
import { ConnectionError } from "../../../../src/common/api/common/error/RestError"
import { assertNotNull, clamp, lastThrow, pad } from "@tutao/tutanota-utils"
import { LoadedMail } from "../../../../src/mail-app/mail/model/MailSetListModel"
import { ConversationListModel } from "../../../../src/mail-app/mail/model/ConversationListModel"
import { theme } from "../../../../src/common/gui/theme.js"
import { ListLoadingState } from "../../../../src/common/gui/base/List"
import { getMailFilterForType, MailFilterType } from "../../../../src/mail-app/mail/view/MailViewerUtils"
o.spec("ConversationListModel", () => {
let model: ConversationListModel
const mailboxDetail: MailboxDetail = {
mailbox: createTestEntity(MailBoxTypeRef),
mailGroupInfo: createTestEntity(GroupInfoTypeRef),
mailGroup: createTestEntity(GroupTypeRef),
mailboxGroupRoot: createTestEntity(MailboxGroupRootTypeRef),
}
const noPatchesAndInstance: Pick<EntityUpdateData, "instance" | "patches"> = {
instance: null,
patches: null,
}
const mailSetEntriesListId = "entries"
const _ownerGroup = "me"
const labels: MailFolder[] = [
createTestEntity(MailFolderTypeRef, {
_id: ["mailFolderList", "tutaPrimary"],
color: theme.primary,
folderType: MailSetKind.LABEL,
name: "Tuta Primary Label",
parentFolder: null,
}),
createTestEntity(MailFolderTypeRef, {
_id: ["mailFolderList", "tutaSecondary"],
color: theme.secondary,
folderType: MailSetKind.LABEL,
name: "Tuta Secondary Label",
parentFolder: null,
}),
]
let mailSet: MailFolder
let conversationPrefProvider: ConversationPrefProvider
let entityClient: EntityClient
let mailModel: MailModel
let inboxRuleHandler: InboxRuleHandler
let cacheStorage: ExposedCacheStorage
o.beforeEach(() => {
mailSet = createTestEntity(MailFolderTypeRef, {
_id: ["mailFolderList", "mailFolderId"],
folderType: MailSetKind.CUSTOM,
name: "My Folder",
entries: mailSetEntriesListId,
parentFolder: null,
})
conversationPrefProvider = object()
entityClient = object()
mailModel = object()
inboxRuleHandler = object()
cacheStorage = object()
model = new ConversationListModel(mailSet, conversationPrefProvider, entityClient, mailModel, inboxRuleHandler, cacheStorage)
when(mailModel.getMailboxDetailsForMailFolder(mailSet)).thenResolve(mailboxDetail)
})
// Care has to be ensured for generating mail set entry IDs as we depend on real mail set ID decoding, thus we have
// some helper methods for generating IDs for these tests.
function makeMailId(index: number): IdTuple {
const mailBag = index % 10
return [`${mailBag}`, pad(index, GENERATED_MAX_ID.length)]
}
function makeMailSetElementId(index: number): Id {
return constructMailSetEntryId(new Date(index * 100), elementIdPart(makeMailId(index)))
}
function mailSetElementIdToIndex(mailSetElementId: Id): number {
return Number(deconstructMailSetEntryId(mailSetElementId).mailId)
}
// Creates a totalMails number of mails, grouping into a number of conversations equal to totalMails/mailsPerConversation
async function setUpTestData(totalMails: number, initialLabels: MailFolder[], offline: boolean, mailsPerConversation: number): Promise<Mail[]> {
const mailSetEntries: MailSetEntry[] = []
const mails: Mail[][] = [[], [], [], [], [], [], [], [], [], []]
const allMails: Mail[] = []
for (let i = 0; i < totalMails; i++) {
const mailBag = i % 10
const mailId: IdTuple = makeMailId(i)
const conversationId = "" + Math.floor(i / mailsPerConversation)
const mail = createTestEntity(MailTypeRef, {
_id: mailId,
sets: [mailSet._id, ...initialLabels.map((l) => l._id)],
conversationEntry: [conversationId, elementIdPart(mailId)],
})
mails[mailBag].push(mail)
allMails.push(mail)
mailSetEntries.push(
createMailSetEntry({
_id: [mailSetEntriesListId, makeMailSetElementId(i)],
_ownerGroup,
_permissions: "1234",
mail: mailId,
}),
)
}
when(mailModel.getLabelsForMail(matchers.anything())).thenDo((mail: Mail) => {
const sets: MailFolder[] = []
for (const set of mail.sets) {
const setToAdd = labels.find((label) => isSameId(label._id, set))
if (setToAdd) {
sets.push(setToAdd)
}
}
return sets
})
// Ensures elements are loaded from the array in reverse order
async function getMailSetEntryMock(_mailSetEntry: any, _listId: Id, startingId: Id, count: number, _reverse: boolean): Promise<MailSetEntry[]> {
let endingIndex: number
if (startingId === CUSTOM_MAX_ID) {
endingIndex = mailSetEntries.length
} else {
endingIndex = mailSetElementIdToIndex(startingId)
}
endingIndex = clamp(endingIndex, 0, mailSetEntries.length)
const startingIndex = clamp(endingIndex - count, 0, endingIndex)
return mailSetEntries.slice(startingIndex, endingIndex).reverse()
}
async function getMailsMock(_mailTypeRef: any, mailBag: string, elements: Id[]): Promise<Mail[]> {
const mailsInMailBag = mails[Number(mailBag)] ?? []
return mailsInMailBag.filter((mail) => elements.includes(getElementId(mail)))
}
when(cacheStorage.provideFromRange(MailSetEntryTypeRef, mailSetEntriesListId, matchers.anything(), matchers.anything(), true)).thenDo(
getMailSetEntryMock,
)
when(cacheStorage.provideMultiple(MailTypeRef, matchers.anything(), matchers.anything())).thenDo(getMailsMock)
if (offline) {
when(entityClient.loadRange(matchers.anything(), matchers.anything(), matchers.anything(), matchers.anything(), matchers.anything())).thenReject(
new ConnectionError("sorry we are offline"),
)
when(entityClient.loadMultiple(matchers.anything(), matchers.anything(), matchers.anything(), matchers.anything())).thenReject(
new ConnectionError("sorry we are offline"),
)
} else {
when(entityClient.loadRange(MailSetEntryTypeRef, mailSetEntriesListId, matchers.anything(), matchers.anything(), true)).thenDo(getMailSetEntryMock)
when(entityClient.loadMultiple(MailTypeRef, matchers.anything(), matchers.anything())).thenDo(getMailsMock)
}
return allMails.reverse()
}
o.test("loads PageSize items and sets labels correctly", async () => {
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
o.check(model.mails.length).equals(PageSize)
for (const mail of model.mails) {
o.check(model.getLabelsForMail(mail)).deepEquals(labels)
}
verify(cacheStorage.provideFromRange(MailSetEntryTypeRef, mailSetEntriesListId, CUSTOM_MAX_ID, PageSize, true), {
times: 0,
})
verify(mailModel.getMailboxDetailsForMailFolder(matchers.anything()), {
times: 0,
})
verify(inboxRuleHandler.findAndApplyMatchingRule(mailboxDetail, matchers.anything(), true), {
times: 0,
})
})
o.test("loads PageSize items while offline and sets labels correctly", async () => {
await setUpTestData(PageSize, labels, true, 1)
await model.loadInitial()
o.check(model.mails.length).equals(PageSize)
for (const mail of model.mails) {
o.check(model.getLabelsForMail(mail)).deepEquals(labels)
}
verify(cacheStorage.provideFromRange(MailSetEntryTypeRef, mailSetEntriesListId, CUSTOM_MAX_ID, PageSize, true), {
times: 1,
})
verify(mailModel.getMailboxDetailsForMailFolder(matchers.anything()), {
times: 0,
})
verify(inboxRuleHandler.findAndApplyMatchingRule(mailboxDetail, matchers.anything(), true), {
times: 0,
})
})
o.test("loads fewer than PageSize items while offline, loadMore will fail", async () => {
const mails = await setUpTestData(PageSize - 1, labels, true, 1)
await model.loadInitial()
o.check(model.mails.length).equals(PageSize - 1)
o.check(model.mails).deepEquals(mails)
for (const mail of model.mails) {
o.check(model.getLabelsForMail(mail)).deepEquals(labels)
}
verify(cacheStorage.provideFromRange(MailSetEntryTypeRef, mailSetEntriesListId, CUSTOM_MAX_ID, PageSize, true), {
times: 1,
})
verify(mailModel.getMailboxDetailsForMailFolder(matchers.anything()), {
times: 0,
})
verify(inboxRuleHandler.findAndApplyMatchingRule(mailboxDetail, matchers.anything(), true), {
times: 0,
})
o.check(model.loadingStatus).equals(ListLoadingState.Idle)
await model.loadMore()
o.check(model.mails.length).equals(PageSize - 1)
o.check(model.mails).deepEquals(mails)
o.check(model.loadingStatus).equals(ListLoadingState.ConnectionLost)
})
o.test("applies inbox rules if inbox", async () => {
mailSet.folderType = MailSetKind.INBOX
// make one item have a rule
when(
inboxRuleHandler.findAndApplyMatchingRule(
mailboxDetail,
matchers.argThat((mail: Mail) => isSameId(mail._id, makeMailId(25))),
true,
),
).thenResolve({})
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
o.check(model.mails.length).equals(PageSize - 1)
for (const mail of model.mails) {
o.check(model.getLabelsForMail(mail)).deepEquals(labels)
}
verify(cacheStorage.provideFromRange(MailSetEntryTypeRef, mailSetEntriesListId, CUSTOM_MAX_ID, PageSize, true), {
times: 0,
})
verify(mailModel.getMailboxDetailsForMailFolder(matchers.anything()), {
times: 1,
})
verify(inboxRuleHandler.findAndApplyMatchingRule(mailboxDetail, matchers.anything(), true), {
times: 100,
})
})
o.spec("loadMore eventually loads more mails", () => {
o.test("ungrouped", async () => {
const mailsPerConversation = 1
const pages = 5
await setUpTestData(PageSize * pages, labels, false, mailsPerConversation)
await model.loadInitial() // will have the first page loaded
const unloadedMail = elementIdPart(makeMailId(1)) // a mail that will be on the bottom of the list
// This mail is not loaded until we load a few more pages.
for (let loadedPageCount = 1; loadedPageCount < pages; loadedPageCount++) {
o.check(model.mails.length).equals(PageSize * loadedPageCount)
const mail = model.getMail(unloadedMail)
o.check(mail).equals(null)
await model.loadMore()
}
// Everything is loaded including that mail we wanted from before
o.check(model.mails.length).equals(PageSize * pages)
const mail = model.getMail(unloadedMail)
o.check(mail).notEquals(null)
})
o.test("grouped by conversations", async () => {
const mailsPerConversation = 2
const pages = 4
await setUpTestData(PageSize * pages * mailsPerConversation, labels, false, mailsPerConversation)
await model.loadInitial() // will have the first page loaded
const unloadedMail = elementIdPart(makeMailId(1)) // a mail that will be on the bottom of the list
// This mail is not loaded until we load a few more pages.
for (let loadedPageCount = 1; loadedPageCount < pages * mailsPerConversation; loadedPageCount++) {
const mail = model.getMail(unloadedMail)
o.check(mail).equals(null)
await model.loadMore()
}
// Everything is now loaded, including that mail we wanted from before
o.check(model.mails.length).equals(PageSize * pages * mailsPerConversation)
// But we have fewer pages shown because half of them are hidden behind conversations where there are newer mails
o.check(model.items.length).equals(PageSize * pages)
const mail = model.getMail(unloadedMail)
o.check(mail).notEquals(null)
})
o.test("everything is one conversation", async () => {
const pages = 4
const totalMails = PageSize * pages
await setUpTestData(totalMails, labels, false, totalMails)
await model.loadInitial() // will have the first page loaded
await model.loadAll()
o.check(model.mails.length).equals(totalMails)
o.check(model.items.length).equals(1)
})
})
o.test("loadAndSelect selects by mail id", async () => {
await setUpTestData(PageSize * 5, labels, false, 1)
await model.loadInitial() // will have the first page loaded
// This mail is not loaded yet.
const unloadedMail = elementIdPart(makeMailId(1)) // a mail that will be on the bottom of the list
const mail = model.getMail(unloadedMail)
o.check(mail).equals(null)
o.check(model.getSelectedAsArray()).deepEquals([])
// Should now be loaded
const loadedMail = assertNotNull(await model.loadAndSelect(unloadedMail, () => false))
o.check(loadedMail).equals(model.getMail(unloadedMail))
// ...and selected
o.check(model.getSelectedAsArray()).deepEquals([loadedMail])
})
o.test("handle create events while already loaded", async () => {
const loadedMails = await setUpTestData(PageSize, labels, false, 1)
const mail = lastThrow(loadedMails)
await model.loadInitial()
// the loaded mails are in reverse order, so we take the 0th element to get the last
const mailSetEntryId: IdTuple = [mailSetEntriesListId, makeMailSetElementId(0)]
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: listIdPart(mailSetEntryId) as NonEmptyString,
instanceId: elementIdPart(mailSetEntryId),
operation: OperationType.CREATE,
instance: null,
patches: null,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailSetEntryTypeRef, mailSetEntryId)).thenResolve(
createTestEntity(MailSetEntryTypeRef, {
_id: mailSetEntryId,
mail: mail._id,
}),
)
await model.handleEntityUpdate(entityUpdateData)
o.check(model._getConversationMap().get(listIdPart(mail.conversationEntry))?.getMainMail()!.mailSetEntryId).deepEquals(mailSetEntryId)
})
o.spec("handleEntityUpdate", () => {
o.test("mailset update updates labels", async () => {
await setUpTestData(PageSize, [labels[0]], false, 1)
await model.loadInitial()
// Overwrite one of the mails inside the list so it has both labels
const someIndex = 50 // a random number
const someMail: LoadedMail = {
...model._getLoadedMail(elementIdPart(makeMailId(someIndex)))!,
labels: [labels[0], labels[1]],
}
someMail.mail.sets.push(labels[1]._id)
model._insertOrUpdateLoadedMails([someMail])
o.check(model.getLabelsForMail(someMail.mail)[1]).deepEquals(labels[1])
// Change one of the labels (but not inside the mail we just updated)
labels[1] = {
...labels[1],
name: "Mint",
color: "#00FFAA",
}
o.check(model.getLabelsForMail(someMail.mail)[1]).notDeepEquals(labels[1])
const entityUpdateData: EntityUpdateData = {
typeRef: MailFolderTypeRef,
instanceListId: getListId(labels[1]) as NonEmptyString,
instanceId: getElementId(labels[1]),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
const oldMails = model.mails
entityUpdateData.operation = OperationType.UPDATE
await model.handleEntityUpdate(entityUpdateData)
o.check(model.getLabelsForMail(someMail.mail)[1]).deepEquals(labels[1])
// verify getLabelsForMail call times (someMail was queried twice, but other mails only once)
verify(mailModel.getLabelsForMail(someMail.mail), { times: 2 })
verify(mailModel.getLabelsForMail(model.mails[someIndex + 1]), { times: 1 })
// does not break referential equality with mails (items is not guaranteed and is usually broken if *any*
// update is made to the list)
o.check(model.mails).equals(oldMails)
})
o.test("mailset delete does nothing", async () => {
await setUpTestData(PageSize, [labels[0]], false, 1)
await model.loadInitial()
const entityUpdateData: EntityUpdateData = {
typeRef: MailFolderTypeRef,
instanceListId: getListId(labels[1]) as NonEmptyString,
instanceId: getElementId(labels[1]),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
entityUpdateData.operation = OperationType.DELETE
const oldMails = model.mails
const oldItems = model.items
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails.length).equals(PageSize)
// no change to referential equality
o.check(model.items).equals(oldItems)
o.check(model.mails).equals(oldMails)
})
o.test("deleting a mail set entry", async () => {
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
const someIndex = 22 // a random number
const someMail: LoadedMail = model._getLoadedMail(elementIdPart(makeMailId(someIndex)))!
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: listIdPart(someMail.mailSetEntryId) as NonEmptyString,
instanceId: elementIdPart(someMail.mailSetEntryId),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
const oldItems = model.mails
const newItems = [...oldItems]
newItems.splice(PageSize - 1 - someIndex, 1)
o.check(model.mails).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newItems)
o.check(model.getMail(getElementId(someMail.mail))).equals(null)
})
function createInsertedMail(
mailSetEntryId: IdTuple,
conversationId: Id,
): {
mail: Mail
mailSetEntry: MailSetEntry
entityUpdateData: EntityUpdateData
mailLabels: MailFolder[]
} {
const newMail = createTestEntity(MailTypeRef, {
_id: ["new mail!!!", deconstructMailSetEntryId(elementIdPart(mailSetEntryId)).mailId],
sets: [mailSet._id, labels[1]._id],
conversationEntry: [conversationId, "yay!"],
})
const newEntry = createMailSetEntry({
_id: mailSetEntryId,
mail: newMail._id,
})
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: getListId(newEntry) as NonEmptyString,
instanceId: getElementId(newEntry),
operation: OperationType.CREATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailSetEntryTypeRef, newEntry._id)).thenResolve(newEntry)
when(entityClient.loadMultiple(MailTypeRef, getListId(newMail), [getElementId(newMail)])).thenResolve([newMail])
return {
mail: newMail,
mailSetEntry: newEntry,
entityUpdateData,
mailLabels: [labels[1]],
}
}
o.test("creating a mail set entry of the same set adds the element", async () => {
await setUpTestData(3, labels, false, 1)
await model.loadInitial()
const { mail, entityUpdateData, mailLabels } = createInsertedMail([mailSet.entries, CUSTOM_MAX_ID], "1")
const oldItems = model.mails
// NOTE: mails is backed by a Map which maintains insertion order; MailSetListModel#mails is not required to
// be ordered
const newItems = [...oldItems, mail]
o.check(model.mails).equals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newItems)
o.check(model.getMail(getElementId(mail))).deepEquals(mail)
o.check(model.getLabelsForMail(mail)).deepEquals(mailLabels)
})
o.test("creating an older mail in an existing conversation", async () => {
await setUpTestData(1, labels, false, 1)
await model.loadInitial()
const { mail, entityUpdateData } = createInsertedMail([mailSetEntriesListId, CUSTOM_MIN_ID], "0")
const oldMails = model.mails
const newMails = [...oldMails, mail]
const oldItems = model.items
const newItems = [...oldItems]
o.check(model.mails).deepEquals(oldMails)
o.check(model.items).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newMails)
o.check(model.items).deepEquals(newItems)
o.check(model.getMail(getElementId(mail))).equals(mail)
})
o.test("creating a newer mail in an existing conversation", async () => {
await setUpTestData(1, labels, false, 1)
await model.loadInitial()
const { mail, entityUpdateData } = createInsertedMail([mailSetEntriesListId, CUSTOM_MAX_ID], "0")
const oldMails = model.mails
const newMails = [...oldMails, mail]
const oldItems = model.items
const newItems = [mail]
o.check(model.mails).deepEquals(oldMails)
o.check(model.items).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newMails)
o.check(model.items).deepEquals(newItems)
o.check(model.getMail(getElementId(mail))).equals(mail)
})
o.test("deleting an older mail in an existing conversation", async () => {
await setUpTestData(2, labels, false, 2)
await model.loadInitial()
const oldMails = model.mails
const newMails = [oldMails[0]]
const oldItems = model.items
const newItems = [...oldItems]
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: mailSetEntriesListId,
instanceId: makeMailSetElementId(0),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
o.check(model.mails).deepEquals(oldMails)
o.check(model.items).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newMails)
o.check(model.items).deepEquals(newItems)
o.check(model.getMail(entityUpdateData.instanceId)).equals(null)
})
o.test("deleting the newest mail in an existing conversation of 3 items selects the second newest", async () => {
await setUpTestData(3, labels, false, 3)
await model.loadInitial()
const oldMails = model.mails
const newMails = [oldMails[1], oldMails[2]]
const oldItems = model.items
const newItems = [oldMails[1]]
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: mailSetEntriesListId,
instanceId: makeMailSetElementId(2),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
o.check(model.mails).deepEquals(oldMails)
o.check(model.items).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newMails)
o.check(model.items).deepEquals(newItems)
o.check(model.getMail(entityUpdateData.instanceId)).equals(null)
})
o.test("deleting a newer mail in an existing conversation of 2 items", async () => {
await setUpTestData(2, labels, false, 2)
await model.loadInitial()
const oldMails = model.mails
const newMails = [oldMails[1]]
const oldItems = model.items
const newItems = [oldMails[1]]
const entityUpdateData: EntityUpdateData = {
typeRef: MailSetEntryTypeRef,
instanceListId: mailSetEntriesListId,
instanceId: makeMailSetElementId(1),
operation: OperationType.DELETE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
o.check(model.mails).deepEquals(oldMails)
o.check(model.items).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newMails)
o.check(model.items).deepEquals(newItems)
o.check(model.getMail(entityUpdateData.instanceId)).equals(null)
})
o.test("creating a mail set entry in a different set does nothing", async () => {
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
const { mail, entityUpdateData } = createInsertedMail(["something else", CUSTOM_MAX_ID], "whoo!")
const oldItems = model.mails
const newItems = [...oldItems]
o.check(model.mails).deepEquals(oldItems)
await model.handleEntityUpdate(entityUpdateData)
o.check(model.mails).deepEquals(newItems)
o.check(model.getMail(getElementId(mail))).equals(null)
})
o.test("updating a mail updates the contents", async () => {
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
const mail = { ...model.mails[2] }
mail.subject = "hey it's a subject"
mail.sets = [mailSet._id] // remove all labels
const entityUpdateData: EntityUpdateData = {
typeRef: MailTypeRef,
instanceListId: getListId(mail) as NonEmptyString,
instanceId: getElementId(mail),
operation: OperationType.UPDATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailTypeRef, mail._id)).thenResolve(mail)
entityUpdateData.operation = OperationType.UPDATE
const oldMails = model.mails
const oldItems = model.items
await model.handleEntityUpdate(entityUpdateData)
o.check(model.getMail(getElementId(mail))).deepEquals(mail)
o.check(model.getLabelsForMail(mail)).deepEquals([])
// Referential equality is broken
o.check(model.mails).notEquals(oldMails)
o.check(model.items).notEquals(oldItems)
})
o.test("mail delete does nothing", async () => {
await setUpTestData(PageSize, labels, false, 1)
await model.loadInitial()
const mail = { ...model.mails[2] }
const entityUpdateData: EntityUpdateData = {
typeRef: MailTypeRef,
instanceListId: getListId(mail) as NonEmptyString,
instanceId: getElementId(mail),
operation: OperationType.UPDATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailTypeRef, mail._id)).thenResolve(mail)
entityUpdateData.operation = OperationType.DELETE
await model.handleEntityUpdate(entityUpdateData)
o.check(model.getMail(getElementId(mail))).deepEquals(mail)
})
})
o.spec("filter on ConversationList", () => {
o.test("When filtering for unread mails only relevant conversations are shown", async () => {
const allMails = await setUpTestData(2, [], false, 1)
await model.loadInitial()
o.check(model.items.length).equals(2)
const unreadMail = allMails[0]
unreadMail.unread = true
const entityUpdateData: EntityUpdateData = {
typeRef: MailTypeRef,
instanceListId: getListId(unreadMail) as NonEmptyString,
instanceId: getElementId(unreadMail),
operation: OperationType.UPDATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailTypeRef, unreadMail._id)).thenResolve(unreadMail)
entityUpdateData.operation = OperationType.UPDATE
await model.handleEntityUpdate(entityUpdateData)
model.setFilter([getMailFilterForType(MailFilterType.Unread)])
const unreadMails = model.items
o.check(unreadMails.length).equals(1)
})
o.test("When the mail does not match filter after filter was set, it is still kept in the list", async () => {
const allMails = await setUpTestData(2, [], false, 1)
await model.loadInitial()
o.check(model.items.length).equals(2)
model.setFilter([getMailFilterForType(MailFilterType.Read)])
const unreadMail = allMails[0]
unreadMail.unread = true
const entityUpdateData: EntityUpdateData = {
typeRef: MailTypeRef,
instanceListId: getListId(unreadMail) as NonEmptyString,
instanceId: getElementId(unreadMail),
operation: OperationType.UPDATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailTypeRef, unreadMail._id)).thenResolve(unreadMail)
entityUpdateData.operation = OperationType.UPDATE
await model.handleEntityUpdate(entityUpdateData)
const unreadMails = model.items
o.check(unreadMails.length).equals(2)
})
o.test("When filter is set, the relevant Email in the conversation is shown", async () => {
const allMails = await setUpTestData(5, [], false, 5)
await model.loadInitial()
let displayedItem = model.items
o.check(isSameId(displayedItem[0]._id, allMails[0]._id)).equals(true)
const unreadMail = allMails[2]
unreadMail.unread = true
const entityUpdateData: EntityUpdateData = {
typeRef: MailTypeRef,
instanceListId: getListId(unreadMail) as NonEmptyString,
instanceId: getElementId(unreadMail),
operation: OperationType.UPDATE,
...noPatchesAndInstance,
prefetchStatus: PrefetchStatus.NotPrefetched,
}
when(entityClient.load(MailTypeRef, unreadMail._id)).thenResolve(unreadMail)
entityUpdateData.operation = OperationType.UPDATE
await model.handleEntityUpdate(entityUpdateData)
model.setFilter([getMailFilterForType(MailFilterType.Unread)])
displayedItem = model.items
o.check(isSameId(displayedItem[0]._id, unreadMail._id)).equals(true)
})
})
})
Reference in a new issue View git blame Copy permalink