mirror of
https://github.com/fluxerapp/fluxer
synced 2026-10-10 12:42:27 +09:00
109 lines
3.4 KiB
TypeScript
109 lines
3.4 KiB
TypeScript
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
import {
|
|
type ChannelID,
|
|
createChannelID,
|
|
createMessageID,
|
|
createUserID,
|
|
type MessageID,
|
|
type UserID,
|
|
} from '@app/api/BrandedTypes';
|
|
import {MessageProcessingService} from '@app/api/channel/services/message/MessageProcessingService';
|
|
import type {ChannelRow} from '@app/api/database/types/ChannelTypes';
|
|
import type {IGatewayService} from '@app/api/infrastructure/IGatewayService';
|
|
import type {UserCacheService} from '@app/api/infrastructure/UserCacheService';
|
|
import type {RequestCache} from '@app/api/middleware/RequestCacheMiddleware';
|
|
import {Channel} from '@app/api/models/Channel';
|
|
import type {IUserRepository} from '@app/api/user/IUserRepository';
|
|
import {ChannelTypes} from '@fluxer/constants/src/ChannelConstants';
|
|
import {describe, expect, it} from 'vitest';
|
|
|
|
const CHANNEL_ID = createChannelID(1532860318772891648n);
|
|
const AUTHOR_ID = createUserID(1471426754353995881n);
|
|
const RECIPIENT_ID = createUserID(1485344055661987728n);
|
|
const MESSAGE_ID = createMessageID(1546325276953149440n);
|
|
|
|
function dmChannelRow(lastMessageId: MessageID | null): ChannelRow {
|
|
return {
|
|
channel_id: CHANNEL_ID,
|
|
guild_id: null,
|
|
type: ChannelTypes.DM,
|
|
name: null,
|
|
topic: null,
|
|
icon_hash: null,
|
|
url: null,
|
|
parent_id: null,
|
|
position: null,
|
|
owner_id: null,
|
|
recipient_ids: new Set<UserID>([AUTHOR_ID, RECIPIENT_ID]),
|
|
nsfw: null,
|
|
content_warning_level: null,
|
|
content_warning_text: null,
|
|
rate_limit_per_user: null,
|
|
bitrate: null,
|
|
user_limit: null,
|
|
voice_connection_limit: null,
|
|
rtc_region: null,
|
|
last_message_id: lastMessageId,
|
|
last_pin_timestamp: null,
|
|
permission_overwrites: null,
|
|
nicks: null,
|
|
soft_deleted: false,
|
|
indexed_at: null,
|
|
version: 0,
|
|
};
|
|
}
|
|
|
|
function buildService(): {service: MessageProcessingService; opened: Array<Channel>} {
|
|
const opened: Array<Channel> = [];
|
|
const userRepository = {
|
|
isDmChannelOpen: async (userId: UserID, _channelId: ChannelID) => userId === AUTHOR_ID,
|
|
openPrivateChannelForUser: async (_userId: UserID, channel: Channel) => {
|
|
opened.push(channel);
|
|
},
|
|
} as unknown as IUserRepository;
|
|
const userCacheService = {
|
|
getUserPartialResponses: async (userIds: Array<UserID>) =>
|
|
new Map(userIds.map((userId) => [userId, {id: userId.toString()}])),
|
|
} as unknown as UserCacheService;
|
|
const gatewayService = {
|
|
dispatchPresence: async () => {},
|
|
} as unknown as IGatewayService;
|
|
const service = new MessageProcessingService(
|
|
undefined as never,
|
|
userRepository,
|
|
userCacheService,
|
|
gatewayService,
|
|
undefined as never,
|
|
undefined as never,
|
|
);
|
|
return {service, opened};
|
|
}
|
|
|
|
describe('MessageProcessingService.updateDMRecipients', () => {
|
|
it('snapshots the new message id when the in-request channel is stale', async () => {
|
|
const {service, opened} = buildService();
|
|
await service.updateDMRecipients({
|
|
channel: new Channel(dmChannelRow(null)),
|
|
channelId: CHANNEL_ID,
|
|
messageId: MESSAGE_ID,
|
|
requestCache: {} as RequestCache,
|
|
});
|
|
expect(opened).toHaveLength(1);
|
|
expect(opened[0].lastMessageId).toBe(MESSAGE_ID);
|
|
});
|
|
|
|
it('keeps a newer last message id already present on the channel', async () => {
|
|
const {service, opened} = buildService();
|
|
const newer = createMessageID(MESSAGE_ID + 10n);
|
|
await service.updateDMRecipients({
|
|
channel: new Channel(dmChannelRow(newer)),
|
|
channelId: CHANNEL_ID,
|
|
messageId: MESSAGE_ID,
|
|
requestCache: {} as RequestCache,
|
|
});
|
|
expect(opened).toHaveLength(1);
|
|
expect(opened[0].lastMessageId).toBe(newer);
|
|
});
|
|
});
|