SnowLuma/packages/sdk/tests/guards.test.ts

import { describe, expect, it } from 'vitest';
import {
    isBotStatusEvent,
    isGroupMessageEvent,
    isMessageEvent,
    isMetaEvent,
    isNoticeEvent,
    isPrivateMessageEvent,
    isRequestEvent,
    noticeType,
    requestType,
    type OneBotGroupMessageEvent,
    type OneBotMetaEvent,
    type OneBotNoticeEvent,
    type OneBotPrivateMessageEvent,
    type OneBotRequestEvent,
    type SnowLumaEvent,
} from '../src';

const PRIVATE_MESSAGE: OneBotPrivateMessageEvent = {
    time: 1_700_000_001,
    self_id: 10000,
    post_type: 'message',
    message_type: 'private',
    sub_type: 'friend',
    message_id: 11,
    message_seq: 12,
    user_id: 20001,
    message: [{ type: 'text', data: { text: 'hi' } }],
    raw_message: 'hi',
    font: 0,
    sender: { user_id: 20001, nickname: 'alice' },
};

const PRIVATE_SENT: OneBotPrivateMessageEvent = {
    time: 1_700_000_002,
    self_id: 10000,
    post_type: 'message_sent',
    message_type: 'private',
    sub_type: 'friend',
    message_id: 13,
    user_id: 20002,
    message: 'echo',
    raw_message: 'echo',
    font: 0,
    sender: { user_id: 10000, nickname: 'bot' },
};

const GROUP_MESSAGE: OneBotGroupMessageEvent = {
    time: 1_700_000_003,
    self_id: 10000,
    post_type: 'message',
    message_type: 'group',
    sub_type: 'normal',
    message_id: 21,
    message_seq: 22,
    group_id: 30001,
    user_id: 20003,
    message: [{ type: 'text', data: { text: 'hey' } }],
    raw_message: 'hey',
    font: 0,
    sender: { user_id: 20003, nickname: 'bob', card: 'Bobby', role: 'member' },
};

const GROUP_SENT: OneBotGroupMessageEvent = {
    time: 1_700_000_004,
    self_id: 10000,
    post_type: 'message_sent',
    message_type: 'group',
    sub_type: 'normal',
    message_id: 23,
    group_id: 30002,
    user_id: 10000,
    message: 'sent',
    raw_message: 'sent',
    font: 0,
    sender: { user_id: 10000, nickname: 'bot' },
};

const NOTICE: OneBotNoticeEvent = {
    time: 1_700_000_005,
    self_id: 10000,
    post_type: 'notice',
    notice_type: 'group_increase',
};

const REQUEST: OneBotRequestEvent = {
    time: 1_700_000_006,
    self_id: 10000,
    post_type: 'request',
    request_type: 'friend',
    flag: 'flag-friend-1',
    user_id: 20004,
    comment: 'please',
};

const META: OneBotMetaEvent = {
    time: 1_700_000_007,
    self_id: 10000,
    post_type: 'meta_event',
    meta_event_type: 'heartbeat',
};

const UNKNOWN: SnowLumaEvent = {
    time: 1_700_000_008,
    self_id: 10000,
    post_type: 'unknown',
};

describe('isMessageEvent', () => {
    it('accepts inbound private and group messages', () => {
        expect(isMessageEvent(PRIVATE_MESSAGE)).toBe(true);
        expect(isMessageEvent(GROUP_MESSAGE)).toBe(true);
    });

    it('accepts message_sent private and group events', () => {
        expect(isMessageEvent(PRIVATE_SENT)).toBe(true);
        expect(isMessageEvent(GROUP_SENT)).toBe(true);
    });

    it('rejects message post types whose message_type is not private or group', () => {
        const guild: SnowLumaEvent = {
            time: 9,
            self_id: 10000,
            post_type: 'message',
            message_type: 'guild',
        };
        const sentChannel: SnowLumaEvent = {
            time: 10,
            self_id: 10000,
            post_type: 'message_sent',
            message_type: 'channel',
        };
        const missingType: SnowLumaEvent = {
            time: 11,
            self_id: 10000,
            post_type: 'message',
        };

        expect(isMessageEvent(guild)).toBe(false);
        expect(isMessageEvent(sentChannel)).toBe(false);
        expect(isMessageEvent(missingType)).toBe(false);
    });

    it('rejects non-message events even when message_type is present', () => {
        const noticeShaped: SnowLumaEvent = {
            time: 12,
            self_id: 10000,
            post_type: 'notice',
            notice_type: 'notify',
            message_type: 'private',
        };

        expect(isMessageEvent(NOTICE)).toBe(false);
        expect(isMessageEvent(REQUEST)).toBe(false);
        expect(isMessageEvent(META)).toBe(false);
        expect(isMessageEvent(UNKNOWN)).toBe(false);
        expect(isMessageEvent(noticeShaped)).toBe(false);
    });
});

describe('isPrivateMessageEvent', () => {
    it('accepts private inbound and sent messages', () => {
        expect(isPrivateMessageEvent(PRIVATE_MESSAGE)).toBe(true);
        expect(isPrivateMessageEvent(PRIVATE_SENT)).toBe(true);
    });

    it('rejects group messages and non-message events', () => {
        expect(isPrivateMessageEvent(GROUP_MESSAGE)).toBe(false);
        expect(isPrivateMessageEvent(GROUP_SENT)).toBe(false);
        expect(isPrivateMessageEvent(NOTICE)).toBe(false);
        expect(isPrivateMessageEvent(REQUEST)).toBe(false);
        expect(isPrivateMessageEvent(META)).toBe(false);
    });

    it('rejects private message_type when post_type is not a message kind', () => {
        const leftover: SnowLumaEvent = {
            time: 13,
            self_id: 10000,
            post_type: 'notice',
            notice_type: 'friend_add',
            message_type: 'private',
        };

        expect(isPrivateMessageEvent(leftover)).toBe(false);
    });
});

describe('isGroupMessageEvent', () => {
    it('accepts group inbound and sent messages', () => {
        expect(isGroupMessageEvent(GROUP_MESSAGE)).toBe(true);
        expect(isGroupMessageEvent(GROUP_SENT)).toBe(true);
    });

    it('rejects private messages and non-message events', () => {
        expect(isGroupMessageEvent(PRIVATE_MESSAGE)).toBe(false);
        expect(isGroupMessageEvent(PRIVATE_SENT)).toBe(false);
        expect(isGroupMessageEvent(NOTICE)).toBe(false);
        expect(isGroupMessageEvent(REQUEST)).toBe(false);
        expect(isGroupMessageEvent(META)).toBe(false);
    });

    it('rejects group message_type when post_type is not a message kind', () => {
        const leftover: SnowLumaEvent = {
            time: 14,
            self_id: 10000,
            post_type: 'request',
            request_type: 'group',
            flag: 'flag-x',
            message_type: 'group',
        };

        expect(isGroupMessageEvent(leftover)).toBe(false);
    });
});

describe('isNoticeEvent', () => {
    it('accepts notice events with a string notice_type', () => {
        expect(isNoticeEvent(NOTICE)).toBe(true);
        expect(
            isNoticeEvent({
                time: 15,
                self_id: 10000,
                post_type: 'notice',
                notice_type: '',
            }),
        ).toBe(true);
    });

    it('rejects notice post_type when notice_type is not a string', () => {
        const missing: SnowLumaEvent = {
            time: 16,
            self_id: 10000,
            post_type: 'notice',
        };
        const numeric: SnowLumaEvent = {
            time: 17,
            self_id: 10000,
            post_type: 'notice',
            notice_type: 7,
        };
        const nulled: SnowLumaEvent = {
            time: 18,
            self_id: 10000,
            post_type: 'notice',
            notice_type: null,
        };

        expect(isNoticeEvent(missing)).toBe(false);
        expect(isNoticeEvent(numeric)).toBe(false);
        expect(isNoticeEvent(nulled)).toBe(false);
    });

    it('accepts bot_status notices and rejects incomplete ones', () => {
        expect(
            isBotStatusEvent({
                time: 19,
                self_id: 10000,
                post_type: 'notice',
                notice_type: 'bot_status',
                sub_type: 'online',
                user_id: 10000,
            }),
        ).toBe(true);
        expect(
            isBotStatusEvent({
                time: 20,
                self_id: 10000,
                post_type: 'notice',
                notice_type: 'bot_status',
                sub_type: 'offline',
                user_id: 10000,
            }),
        ).toBe(true);
        expect(isBotStatusEvent(NOTICE)).toBe(false);
        expect(
            isBotStatusEvent({
                time: 21,
                self_id: 10000,
                post_type: 'notice',
                notice_type: 'bot_status',
                sub_type: 'flap',
                user_id: 10000,
            }),
        ).toBe(false);
    });

    it('rejects other post types', () => {
        expect(isNoticeEvent(PRIVATE_MESSAGE)).toBe(false);
        expect(isNoticeEvent(REQUEST)).toBe(false);
        expect(isNoticeEvent(META)).toBe(false);
        expect(isNoticeEvent(UNKNOWN)).toBe(false);
    });
});

describe('isRequestEvent', () => {
    it('accepts request events with string request_type and flag', () => {
        expect(isRequestEvent(REQUEST)).toBe(true);
        expect(
            isRequestEvent({
                time: 19,
                self_id: 10000,
                post_type: 'request',
                request_type: 'group',
                sub_type: 'add',
                flag: '',
                group_id: 30003,
            }),
        ).toBe(true);
    });

    it('rejects request post_type when request_type or flag is not a string', () => {
        const missingFlag: SnowLumaEvent = {
            time: 20,
            self_id: 10000,
            post_type: 'request',
            request_type: 'friend',
        };
        const numericFlag: SnowLumaEvent = {
            time: 21,
            self_id: 10000,
            post_type: 'request',
            request_type: 'friend',
            flag: 99,
        };
        const missingType: SnowLumaEvent = {
            time: 22,
            self_id: 10000,
            post_type: 'request',
            flag: 'flag-2',
        };
        const numericType: SnowLumaEvent = {
            time: 23,
            self_id: 10000,
            post_type: 'request',
            request_type: 1,
            flag: 'flag-3',
        };
        const nullFlag: SnowLumaEvent = {
            time: 24,
            self_id: 10000,
            post_type: 'request',
            request_type: 'friend',
            flag: null,
        };

        expect(isRequestEvent(missingFlag)).toBe(false);
        expect(isRequestEvent(numericFlag)).toBe(false);
        expect(isRequestEvent(missingType)).toBe(false);
        expect(isRequestEvent(numericType)).toBe(false);
        expect(isRequestEvent(nullFlag)).toBe(false);
    });

    it('rejects other post types even when request fields are present', () => {
        const leftover: SnowLumaEvent = {
            time: 25,
            self_id: 10000,
            post_type: 'notice',
            notice_type: 'group_ban',
            request_type: 'group',
            flag: 'flag-4',
        };

        expect(isRequestEvent(PRIVATE_MESSAGE)).toBe(false);
        expect(isRequestEvent(NOTICE)).toBe(false);
        expect(isRequestEvent(META)).toBe(false);
        expect(isRequestEvent(leftover)).toBe(false);
    });
});

describe('isMetaEvent', () => {
    it('accepts meta_event events with a string meta_event_type', () => {
        expect(isMetaEvent(META)).toBe(true);
        expect(
            isMetaEvent({
                time: 26,
                self_id: 10000,
                post_type: 'meta_event',
                meta_event_type: 'lifecycle',
            }),
        ).toBe(true);
    });

    it('rejects meta_event post_type when meta_event_type is not a string', () => {
        const missing: SnowLumaEvent = {
            time: 27,
            self_id: 10000,
            post_type: 'meta_event',
        };
        const numeric: SnowLumaEvent = {
            time: 28,
            self_id: 10000,
            post_type: 'meta_event',
            meta_event_type: 0,
        };
        const nulled: SnowLumaEvent = {
            time: 29,
            self_id: 10000,
            post_type: 'meta_event',
            meta_event_type: null,
        };

        expect(isMetaEvent(missing)).toBe(false);
        expect(isMetaEvent(numeric)).toBe(false);
        expect(isMetaEvent(nulled)).toBe(false);
    });

    it('rejects other post types', () => {
        expect(isMetaEvent(PRIVATE_MESSAGE)).toBe(false);
        expect(isMetaEvent(NOTICE)).toBe(false);
        expect(isMetaEvent(REQUEST)).toBe(false);
        expect(isMetaEvent(UNKNOWN)).toBe(false);
    });
});

describe('noticeType', () => {
    it('matches notice events by notice_type', () => {
        const isIncrease = noticeType('group_increase');
        const isDecrease = noticeType('group_decrease');

        expect(isIncrease(NOTICE)).toBe(true);
        expect(isDecrease(NOTICE)).toBe(false);
        expect(
            isIncrease({
                time: 30,
                self_id: 10000,
                post_type: 'notice',
                notice_type: 'group_decrease',
            }),
        ).toBe(false);
    });

    it('rejects events that fail isNoticeEvent', () => {
        const isIncrease = noticeType('group_increase');
        const missingType: SnowLumaEvent = {
            time: 31,
            self_id: 10000,
            post_type: 'notice',
        };
        const leftover: SnowLumaEvent = {
            time: 32,
            self_id: 10000,
            post_type: 'message',
            message_type: 'private',
            notice_type: 'group_increase',
        };

        expect(isIncrease(missingType)).toBe(false);
        expect(isIncrease(leftover)).toBe(false);
        expect(isIncrease(REQUEST)).toBe(false);
        expect(isIncrease(PRIVATE_MESSAGE)).toBe(false);
    });
});

describe('requestType', () => {
    it('matches request events by request_type', () => {
        const isFriend = requestType('friend');
        const isGroup = requestType('group');

        expect(isFriend(REQUEST)).toBe(true);
        expect(isGroup(REQUEST)).toBe(false);
        expect(
            isFriend({
                time: 33,
                self_id: 10000,
                post_type: 'request',
                request_type: 'group',
                flag: 'flag-group-1',
            }),
        ).toBe(false);
    });

    it('rejects events that fail isRequestEvent', () => {
        const isFriend = requestType('friend');
        const missingFlag: SnowLumaEvent = {
            time: 34,
            self_id: 10000,
            post_type: 'request',
            request_type: 'friend',
        };
        const leftover: SnowLumaEvent = {
            time: 35,
            self_id: 10000,
            post_type: 'notice',
            notice_type: 'friend_add',
            request_type: 'friend',
            flag: 'flag-5',
        };

        expect(isFriend(missingFlag)).toBe(false);
        expect(isFriend(leftover)).toBe(false);
        expect(isFriend(NOTICE)).toBe(false);
        expect(isFriend(META)).toBe(false);
    });
});