Skip to content

armgit / zulip

Public Imported from GitHub
0

Zulip server and web application. Open-source team chat that helps teams stay productive and focused.

11.3 KB
Raw Blame
"use strict";

const assert = require("node:assert/strict");

const {make_realm} = require("./lib/example_realm.cjs");
const {make_stream} = require("./lib/example_stream.cjs");
const {make_user} = require("./lib/example_user.cjs");
const {mock_esm, zrequire} = require("./lib/namespace.cjs");
const {run_test, noop} = require("./lib/test.cjs");
const {$} = require("./lib/zjquery.cjs");

const message_edit = mock_esm("../src/message_edit");
const message_lists = mock_esm("../src/message_lists");
const message_notifications = mock_esm("../src/message_notifications");
const pm_list = mock_esm("../src/pm_list");
const stream_list = mock_esm("../src/stream_list");
const unread_ui = mock_esm("../src/unread_ui");
mock_esm("../src/message_parser", {
    message_has_attachment: noop,
    message_has_image: noop,
    message_has_link: noop,
    message_has_link_preview: noop,
});
message_lists.current = {};
message_lists.all_rendered_message_lists = () => [message_lists.current];

const people = zrequire("people");
const linkifiers = zrequire("linkifiers");
const markdown = zrequire("markdown");
const message_events = zrequire("message_events");
const message_helper = zrequire("message_helper");
const message_store = zrequire("message_store");
const {set_realm} = zrequire("state_data");
const stream_data = zrequire("stream_data");
const settings_config = zrequire("settings_config");
const stream_topic_history = zrequire("stream_topic_history");
const unread = zrequire("unread");
const {initialize_user_settings} = zrequire("user_settings");

const realm = make_realm();
set_realm(realm);

initialize_user_settings({user_settings: {}});

const alice = make_user({
    email: "[email protected]",
    user_id: 32,
    full_name: "Alice Patel",
});

people.add_active_user(alice);

const denmark = make_stream({
    subscribed: true,
    name: "Denmark",
    stream_id: 101,
});
stream_data.add_sub_for_tests(denmark);

function test_helper(side_effects) {
    const events = [];

    for (const [module, field] of side_effects) {
        module[field] = () => {
            events.push([module, field]);
        };
    }

    return {
        verify() {
            assert.deepEqual(side_effects, events);
        },
    };
}

run_test("update_messages", ({override, override_rewire}) => {
    override_rewire(message_events, "update_views_filtered_on_message_property", () => {});

    const raw_message = {
        id: 111,
        display_recipient: denmark.name,
        flags: ["mentioned"],
        sender_id: alice.user_id,
        stream_id: denmark.stream_id,
        topic: "lunch",
        type: "stream",
        content: "",
        reactions: [],
        submessages: [],
        avatar_url: `/avatar/${alice.user_id}`,
    };

    const original_message = message_helper.process_new_message({
        type: "server_message",
        raw_message,
    }).message;

    assert.equal(original_message.mentioned, true);
    assert.equal(original_message.unread, true);

    assert.deepEqual(stream_topic_history.get_recent_topic_names(denmark.stream_id), ["lunch"]);

    unread.update_message_for_mention(original_message);
    assert.ok(unread.unread_mentions_counter.has(original_message.id));

    const events = [
        {
            message_id: original_message.id,
            flags: [],
            orig_content: "old stuff",
            content: "**new content**",
            rendered_content: "<b>new content</b>",
        },
    ];

    message_lists.current.view = {};

    let rendered_msgs;

    message_lists.current.view.rerender_messages = (msgs_to_rerender, message_content_edited) => {
        rendered_msgs = msgs_to_rerender;
        assert.equal(message_content_edited, true);
    };

    const side_effects = [
        [message_edit, "end_message_edit"],
        [message_notifications, "received_messages"],
        [unread_ui, "update_unread_counts"],
        [stream_list, "update_streams_sidebar"],
        [pm_list, "update_private_messages"],
    ];

    const helper = test_helper(side_effects);

    override(
        realm,
        "realm_message_edit_history_visibility_policy",
        settings_config.message_edit_history_visibility_policy_values.never.code,
    );

    const $message_edit_history_modal = $.create("#message-edit-history");
    const $modal = $.create("micromodal").addClass("modal--open");
    $message_edit_history_modal.set_parents_result(".micromodal", $modal);

    // TEST THIS:
    message_events.update_messages(events);

    assert.ok(!unread.unread_mentions_counter.has(original_message.id));

    helper.verify();

    assert.deepEqual(rendered_msgs, [
        {
            avatar_url: `/avatar/${alice.user_id}`,
            display_reply_to: undefined,
            alerted: false,
            clean_reactions: new Map(),
            collapsed: false,
            content: "<b>new content</b>",
            display_recipient: denmark.name,
            hide_link_previews: false,
            historical: false,
            id: 111,
            is_stream: true,
            is_private: false,
            last_edit_timestamp: undefined,
            mentioned: false,
            stream_wildcard_mentioned: false,
            topic_wildcard_mentioned: false,
            mentioned_me_directly: false,
            raw_content: "**new content**",
            reply_to: alice.email,
            sender_email: alice.email,
            sender_full_name: alice.full_name,
            sender_id: 32,
            sent_by_me: false,
            starred: false,
            status_emoji_info: undefined,
            stream_id: denmark.stream_id,
            stream: "Denmark",
            submessages: [],
            topic: "lunch",
            type: "stream",
            unread: true,
        },
    ]);
});

run_test(
    "update_messages case-only topic name change updates the topic name in UI",
    ({override_rewire}) => {
        override_rewire(message_events, "update_views_filtered_on_message_property", () => {}, {
            unused: false,
        });
        linkifiers.initialize([]);
        markdown.initialize({
            get_linkifier_map: linkifiers.get_linkifier_map,
        });

        const old_topic = "main failing";
        const new_topic = "MAIN failing";
        const raw_message = {
            id: 222,
            display_recipient: denmark.name,
            flags: [],
            sender_id: alice.user_id,
            stream_id: denmark.stream_id,
            topic: old_topic,
            topic_links: markdown.get_topic_links(old_topic),
            type: "stream",
            content: "",
            reactions: [],
            submessages: [],
            avatar_url: `/avatar/${alice.user_id}`,
        };

        const original_message = message_helper.process_new_message({
            type: "server_message",
            raw_message,
        }).message;

        message_lists.current.view = {};
        let rendered_msgs;
        message_lists.current.view.rerender_messages = (msgs_to_rerender) => {
            rendered_msgs = msgs_to_rerender;
        };
        const new_topic_links = markdown.get_topic_links(new_topic);

        const events = [
            {
                message_id: original_message.id,
                message_ids: [original_message.id],
                user_id: alice.user_id,
                flags: [],
                edit_timestamp: 1700000000,
                stream_id: denmark.stream_id,
                orig_subject: old_topic,
                topic: new_topic,
                topic_links: new_topic_links,
                rendering_only: false,
            },
        ];

        const $message_edit_history_modal = $.create("#message-edit-history");
        $message_edit_history_modal.set_parents_result(".micromodal", $.create("micromodal"));

        message_events.update_messages(events);

        assert.equal(original_message.topic, new_topic);
        assert.deepEqual(original_message.topic_links, new_topic_links);
        const topic_names = stream_topic_history.get_recent_topic_names(denmark.stream_id);
        assert.equal(topic_names[0], new_topic);
        assert.deepEqual(rendered_msgs, [original_message]);
    },
);

run_test(
    "update_messages case-only topic name change keeps topic links findable",
    ({override_rewire}) => {
        override_rewire(message_events, "update_views_filtered_on_message_property", () => {}, {
            unused: false,
        });
        message_store.clear_topic_links_for_testing();
        message_lists.current.view = {rerender_messages: noop};
        // update_messages checks whether the edit history modal is open.
        const $message_edit_history_modal = $.create("#message-edit-history");
        $message_edit_history_modal.set_parents_result(".micromodal", $.create("micromodal"));

        const old_topic = "weekend plans";
        const new_topic = "Weekend plans";
        const link = {
            stream_id: denmark.stream_id,
            topic: "dinner",
            message_id: undefined,
            kind: "topic",
        };
        const raw_message = {
            id: 333,
            display_recipient: denmark.name,
            flags: [],
            sender_id: alice.user_id,
            stream_id: denmark.stream_id,
            topic: old_topic,
            type: "stream",
            content: `<a href="/#narrow/channel/${denmark.stream_id}-Denmark/topic/dinner">dinner</a>`,
            reactions: [],
            submessages: [],
            avatar_url: `/avatar/${alice.user_id}`,
        };
        const message = message_helper.process_new_message({
            type: "server_message",
            raw_message,
        }).message;
        assert.deepEqual(message_store.topic_links_from_narrow(denmark.stream_id, old_topic), [
            link,
        ]);
        assert.deepEqual(message_store.topic_links_to_narrow(denmark.stream_id, "dinner"), [
            {
                stream_id: denmark.stream_id,
                topic: old_topic,
                message_id: message.id,
                kind: "message",
            },
        ]);

        const events = [
            {
                message_id: message.id,
                message_ids: [message.id],
                user_id: alice.user_id,
                flags: [],
                edit_timestamp: 1700000000,
                stream_id: denmark.stream_id,
                orig_subject: old_topic,
                topic: new_topic,
                topic_links: [],
                rendering_only: false,
            },
        ];

        message_events.update_messages(events);

        // The links are still found under either spelling of the topic.
        assert.equal(message.topic, new_topic);
        assert.deepEqual(message_store.topic_links_from_narrow(denmark.stream_id, old_topic), [
            link,
        ]);
        assert.deepEqual(message_store.topic_links_from_narrow(denmark.stream_id, new_topic), [
            link,
        ]);
        assert.deepEqual(message_store.topic_links_to_narrow(denmark.stream_id, "dinner"), [
            {
                stream_id: denmark.stream_id,
                topic: new_topic,
                message_id: message.id,
                kind: "message",
            },
        ]);

        // Deleting the message finds its links and removes them.
        message_store.remove([message.id]);
        assert.deepEqual(message_store.topic_links_from_narrow(denmark.stream_id, new_topic), []);
        assert.deepEqual(message_store.topic_links_to_narrow(denmark.stream_id, "dinner"), []);
    },
);