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.

64.3 KB
Raw Blame
"use strict";

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

const {make_user_group} = require("./lib/example_group.cjs");
const {make_realm} = require("./lib/example_realm.cjs");
const {make_stream} = require("./lib/example_stream.cjs");
const {make_user, make_bot, Role} = require("./lib/example_user.cjs");
const {mock_esm, zrequire} = require("./lib/namespace.cjs");
const {run_test} = require("./lib/test.cjs");

const settings_config = zrequire("settings_config");
const pm_conversations = zrequire("pm_conversations");

const bootstrap_typeahead = zrequire("bootstrap_typeahead");
const recent_senders = zrequire("recent_senders");
const peer_data = zrequire("peer_data");
const people = zrequire("people");
const stream_data = zrequire("stream_data");
const stream_list_sort = zrequire("stream_list_sort");
const compose_state = zrequire("compose_state");
const emoji = zrequire("emoji");
const pygments_data = zrequire("pygments_data");
const {set_current_user, set_realm} = zrequire("state_data");
const util = zrequire("util");
const ct = zrequire("composebox_typeahead");
const th = zrequire("typeahead_helper");
const user_groups = zrequire("user_groups");
const {initialize_user_settings} = zrequire("user_settings");

mock_esm("../src/channel", {
    get: () => ({subscribers: []}),
});

const current_user = {};
set_current_user(current_user);
const realm = make_realm();
set_realm(realm);
const user_settings = {};
initialize_user_settings({user_settings});

let next_id = 0;

function assertSameEmails(lst1, lst2) {
    assert.deepEqual(
        lst1.map((r) => r.user.email),
        lst2.map((r) => r.user.email),
    );
}

function user_item(user) {
    return {type: "user", user};
}

function broadcast_item(user) {
    return {type: "broadcast", user};
}

function user_group_item(user_group) {
    return {type: "user_group", ...user_group};
}

const a_bot = make_bot({
    email: "[email protected]",
    full_name: "A Zulip test bot",
    user_id: 1,
});
const a_bot_item = user_item(a_bot);

const a_user = make_user({
    email: "[email protected]",
    full_name: "A Zulip user",
    user_id: 2,
});
const a_user_item = user_item(a_user);

const b_user_1 = make_user({
    email: "[email protected]",
    full_name: "Bob 1",
    user_id: 3,
});
const b_user_1_item = user_item(b_user_1);

const b_user_2 = make_user({
    email: "[email protected]",
    full_name: "Bob 2",
    role: Role.ADMINISTRATOR,
    user_id: 4,
});
const b_user_2_item = user_item(b_user_2);

const b_user_3 = make_user({
    email: "[email protected]",
    full_name: "Bob 3",
    user_id: 5,
});
const b_user_3_item = user_item(b_user_3);

const b_bot = make_bot({
    email: "[email protected]",
    full_name: "B bot",
    user_id: 6,
});
const b_bot_item = user_item(b_bot);

const zman = make_user({
    email: "[email protected]",
    full_name: "Zman",
    user_id: 7,
});
const zman_item = user_item(zman);

const matches = [a_bot, a_user, b_user_1, b_user_2, b_user_3, b_bot, zman];

for (const person of matches) {
    people.add_active_user(person);
}

const dev_sub = make_stream({
    name: "Dev",
    color: "blue",
    stream_id: 1,
    subscriber_count: 0,
    subscribed: true,
});

const linux_sub = make_stream({
    name: "Linux",
    color: "red",
    stream_id: 2,
    subscriber_count: 0,
    subscribed: true,
});
stream_data.create_streams([dev_sub, linux_sub]);
stream_data.add_sub_for_tests(dev_sub);
stream_data.add_sub_for_tests(linux_sub);

const bob_system_group = make_user_group({
    id: 1,
    name: "Bob system group",
    description: "",
    members: new Set(),
    is_system_group: true,
});
const bob_system_group_item = user_group_item(bob_system_group);

const bob_group = make_user_group({
    id: 2,
    name: "Bob group",
    description: "",
    members: new Set(),
    is_system_group: false,
});
const bob_group_item = user_group_item(bob_group);

const second_bob_group = make_user_group({
    id: 3,
    name: "bob 2 group",
    description: "",
    members: new Set([b_user_2.user_id]),
    is_system_group: false,
});

const admins_group = make_user_group({
    id: 4,
    name: "Admins of zulip",
    description: "",
    members: new Set(),
    is_system_group: false,
});
const admins_group_item = user_group_item(admins_group);

const members_group = make_user_group({
    id: 5,
    name: "role:members",
    description: "",
    members: new Set(),
    is_system_group: true,
});
const members_group_item = user_group_item(members_group);

const everyone_group = make_user_group({
    id: 6,
    name: "role:everyone",
    description: "",
    members: new Set(),
    is_system_group: true,
});

user_groups.initialize({
    realm_user_groups: [
        bob_system_group,
        bob_group,
        second_bob_group,
        admins_group,
        members_group,
        everyone_group,
    ],
});

function test(label, f) {
    run_test(label, (helpers) => {
        pm_conversations.clear_for_testing();
        recent_senders.clear_for_testing();
        peer_data.clear_for_testing();
        helpers.override(current_user, "is_admin", false);

        f(helpers);
    });
}

test("sort_streams", ({override}) => {
    let test_streams = [
        {
            stream_id: 101,
            name: "Dev",
            pin_to_top: false,
            stream_weekly_traffic: 0,
            subscribed: true,
            is_muted: false,
            is_recently_active: true,
        },
        {
            stream_id: 102,
            name: "Docs",
            pin_to_top: false,
            stream_weekly_traffic: 100,
            subscribed: true,
            is_muted: false,
            is_recently_active: true,
        },
        {
            stream_id: 103,
            name: "Derp",
            pin_to_top: false,
            stream_weekly_traffic: 0,
            subscribed: true,
            is_muted: true,
            is_recently_active: true,
        },
        {
            stream_id: 104,
            name: "Denmark",
            pin_to_top: true,
            stream_weekly_traffic: 100,
            subscribed: true,
            is_muted: false,
            is_recently_active: true,
        },
        {
            stream_id: 105,
            name: "dead",
            pin_to_top: false,
            stream_weekly_traffic: 0,
            subscribed: true,
            is_muted: false,
            is_recently_active: false,
        },
        {
            stream_id: 106,
            name: "dead (almost)",
            pin_to_top: false,
            stream_weekly_traffic: 2,
            subscribed: true,
            is_muted: false,
            is_recently_active: true,
        },
    ];

    override(
        user_settings,
        "demote_inactive_streams",
        settings_config.demote_inactive_streams_values.always.code,
    );

    stream_list_sort.set_filter_out_inactives();
    compose_state.set_selected_recipient_id(dev_sub.stream_id);

    test_streams = th.sort_streams(test_streams, "d");
    assert.deepEqual(test_streams[0].name, "Dev"); // Stream being composed to
    assert.deepEqual(test_streams[1].name, "Denmark"); // Pinned stream
    assert.deepEqual(test_streams[2].name, "Docs"); // Active stream, more traffic
    assert.deepEqual(test_streams[3].name, "dead (almost)"); // Active stream, less traffic
    assert.deepEqual(test_streams[4].name, "Derp"); // Active but muted stream
    assert.deepEqual(test_streams[5].name, "dead"); // Inactive stream last

    // Sort streams by name
    test_streams = th.sort_streams_by_name(test_streams, "d");
    assert.deepEqual(test_streams[0].name, "dead");
    assert.deepEqual(test_streams[1].name, "dead (almost)");
    assert.deepEqual(test_streams[2].name, "Denmark");
    assert.deepEqual(test_streams[3].name, "Derp");
    assert.deepEqual(test_streams[4].name, "Dev");
    assert.deepEqual(test_streams[5].name, "Docs");

    compose_state.set_selected_recipient_id(linux_sub.stream_id);

    // Test sort streams with description
    test_streams = [
        {
            stream_id: 201,
            name: "Dev",
            description: "development help",
            subscribed: true,
            is_recently_active: true,
        },
        {
            stream_id: 202,
            name: "Docs",
            description: "writing docs",
            subscribed: true,
            is_recently_active: true,
        },
        {
            stream_id: 203,
            name: "Derp",
            description: "derping around",
            subscribed: true,
            is_recently_active: true,
        },
        {
            stream_id: 204,
            name: "Denmark",
            description: "visiting Denmark",
            subscribed: true,
            is_recently_active: true,
        },
        {
            stream_id: 205,
            name: "dead",
            description: "dead stream",
            subscribed: true,
            is_recently_active: false,
        },
    ];

    test_streams = th.sort_streams(test_streams, "wr");
    assert.deepEqual(test_streams[0].name, "Docs"); // Description match
    assert.deepEqual(test_streams[1].name, "Denmark"); // Popular stream
    assert.deepEqual(test_streams[2].name, "Derp"); // Less subscribers
    assert.deepEqual(test_streams[3].name, "Dev"); // Alphabetically last
    assert.deepEqual(test_streams[4].name, "dead"); // Inactive streams last

    // Test sort both subscribed and unsubscribed streams.
    test_streams = [
        {
            stream_id: 301,
            name: "Dev",
            description: "Some devs",
            subscribed: true,
        },
        {
            stream_id: 302,
            name: "East",
            description: "Developing east",
            subscribed: true,
        },
        {
            stream_id: 303,
            name: "New",
            description: "No match",
            subscribed: true,
        },
        {
            stream_id: 304,
            name: "Derp",
            description: "Always derping",
            subscribed: false,
        },
        {
            stream_id: 305,
            name: "Ether",
            description: "Destroying ether",
            subscribed: false,
        },
        {
            stream_id: 306,
            name: "Mew",
            description: "Cat mews",
            subscribed: false,
        },
    ];

    test_streams = th.sort_streams(test_streams, "d");
    assert.deepEqual(test_streams[0].name, "Dev"); // Subscribed and stream name starts with query
    assert.deepEqual(test_streams[1].name, "Derp"); // Unsubscribed and stream name starts with query
    assert.deepEqual(test_streams[2].name, "East"); // Subscribed and description starts with query
    assert.deepEqual(test_streams[3].name, "Ether"); // Unsubscribed and description starts with query
    assert.deepEqual(test_streams[4].name, "New"); // Subscribed and no match
    assert.deepEqual(test_streams[5].name, "Mew"); // Unsubscribed and no match

    // Unsubscribed channels are ordered by recent traffic, then name.
    // "Dusk" sorts after "Dawn" by name, so leading with it confirms
    // traffic takes precedence over the name tiebreaker.
    test_streams = [
        {
            stream_id: 401,
            name: "Dawn",
            subscribed: false,
            stream_weekly_traffic: 5,
        },
        {
            stream_id: 402,
            name: "Dusk",
            subscribed: false,
            stream_weekly_traffic: 50,
        },
    ];

    test_streams = th.sort_streams(test_streams, "d");
    assert.deepEqual(test_streams[0].name, "Dusk"); // More traffic
    assert.deepEqual(test_streams[1].name, "Dawn"); // Less traffic

    // Archived channels sort below all unarchived channels, and within
    // each group subscribed channels sort above unsubscribed ones.
    test_streams = [
        {
            stream_id: 403,
            name: "archived and subscribed",
            subscribed: true,
            is_archived: true,
        },
        {
            stream_id: 404,
            name: "unarchived and subscribed",
            subscribed: true,
            is_archived: false,
        },
        {
            stream_id: 405,
            name: "archived and unsubscribed",
            subscribed: false,
            is_archived: true,
        },
        {
            stream_id: 406,
            name: "unarchived and unsubscribed",
            subscribed: false,
            is_archived: false,
        },
    ];

    test_streams = th.sort_streams(test_streams, "and");
    assert.deepEqual(test_streams[0].name, "unarchived and subscribed");
    assert.deepEqual(test_streams[1].name, "unarchived and unsubscribed");
    assert.deepEqual(test_streams[2].name, "archived and subscribed");
    assert.deepEqual(test_streams[3].name, "archived and unsubscribed");
});

function language_items(languages) {
    return languages.map((language) => ({
        language,
        type: "syntax",
    }));
}

test("sort_languages", ({override, override_rewire}) => {
    override(realm, "realm_default_code_block_language", "dart");
    const default_language = realm.realm_default_code_block_language;

    override_rewire(pygments_data, "langs", {
        python: {priority: 26},
        javascript: {priority: 27},
        php: {priority: 16},
        pascal: {priority: 15},
        perl: {priority: 3},
        css: {priority: 21},
        spoiler: {priority: 29},
        text: {priority: 31},
        quote: {priority: 30},
        math: {priority: 28},
    });

    let test_langs = language_items(["pascal", "perl", "php", "python", "spoiler", "javascript"]);
    test_langs = th.sort_languages(test_langs, "p");

    // Sort languages by matching first letter, and then by popularity
    assert.deepEqual(
        test_langs,
        language_items(["python", "php", "pascal", "perl", "spoiler", "javascript"]),
    );

    // Test if popularity between two languages are the same
    pygments_data.langs.php = {priority: 26};
    test_langs = language_items(["pascal", "perl", "php", "python", "spoiler", "javascript"]);
    test_langs = th.sort_languages(test_langs, "p");

    assert.deepEqual(
        test_langs,
        language_items(["php", "python", "pascal", "perl", "spoiler", "javascript"]),
    );

    test_langs = language_items([
        default_language,
        "text",
        "quote",
        "math",
        "python",
        "javascript",
    ]);
    const test_langs_for_default = th.sort_languages(test_langs, "d");

    assert.deepEqual(
        test_langs_for_default,
        language_items([default_language, "text", "quote", "math", "javascript", "python"]),
    );

    test_langs = th.sort_languages(test_langs, "t");

    assert.deepEqual(
        test_langs,
        language_items(["text", "quote", "math", "javascript", "python", default_language]),
    );
});

test("sort_languages on actual data", () => {
    // Some final tests on the actual pygments data to check ordering.
    //
    // We may eventually want to use human-readable names like
    // "JavaScript" with several machine-readable aliases for what the
    // user typed, which might help provide a better user experience.
    let test_langs = language_items(["j", "java", "javascript", "js"]);

    // Sort according to priority only.
    test_langs = th.sort_languages(test_langs, "jav");
    assert.deepEqual(test_langs, language_items(["javascript", "java", "j"]));

    // Push exact matches to top, regardless of priority
    test_langs = th.sort_languages(test_langs, "java");
    assert.deepEqual(test_langs, language_items(["java", "javascript", "j"]));
    test_langs = th.sort_languages(test_langs, "j");
    assert.deepEqual(test_langs, language_items(["j", "javascript", "java"]));

    // (Only one alias should be shown per language
    // (e.g. searching for "js" shouldn't show "javascript")
    test_langs = language_items(["js", "javascript", "java"]);
    test_langs = th.sort_languages(test_langs, "js");
    assert.deepEqual(test_langs, language_items(["js", "java"]));
});

test("sort_user_groups", () => {
    const test_user_groups = [
        {
            id: 1,
            name: "Developers",
            description: "Group of developers",
        },
        {
            id: 2,
            name: "Designers",
            description: "Group of designers",
        },
        {
            id: 3,
            name: "DevOps",
            description: "Group of DevOps engineers",
        },
        {
            id: 4,
            name: "Docs",
            description: "Group of documentation writers",
        },
        {
            id: 5,
            name: "Devs",
            description: "Another group of developers",
        },
    ];

    // Test sorting by user group name
    let sorted_user_groups = th.sort_user_groups(test_user_groups, "De");

    // Assert that the groups are sorted correctly by name
    assert.deepEqual(sorted_user_groups[0].name, "Designers"); // Exact match with query
    assert.deepEqual(sorted_user_groups[1].name, "Developers");
    assert.deepEqual(sorted_user_groups[2].name, "DevOps");
    assert.deepEqual(sorted_user_groups[3].name, "Devs");
    assert.deepEqual(sorted_user_groups[4].name, "Docs");

    // Test sorting with a different query
    sorted_user_groups = th.sort_user_groups(test_user_groups, "Do");

    assert.deepEqual(sorted_user_groups[0].name, "Docs"); // Exact match with query
    assert.deepEqual(sorted_user_groups[1].name, "Designers");
    assert.deepEqual(sorted_user_groups[2].name, "Developers");
    assert.deepEqual(sorted_user_groups[3].name, "DevOps");
    assert.deepEqual(sorted_user_groups[4].name, "Devs");
});

function get_typeahead_result(query, current_stream_id, current_topic) {
    const users = people.get_realm_users().map((user) => ({type: "user", user}));
    const result = th.sort_recipients({
        users,
        query,
        current_stream_id,
        current_topic,
    });
    return result.map((person) => person.user.email);
}

test("sort_recipients", () => {
    // Typeahead for recipientbox [query, "", undefined]
    assert.deepEqual(get_typeahead_result("b", ""), [
        "[email protected]", // Bob 1 (name prefix match)
        "[email protected]", // Bob 2 (name prefix match)
        "[email protected]", // Bob 3 (name prefix match)
        "[email protected]", // B bot (name prefix match, bot after humans)
        "[email protected]", // A Zulip test bot (matches "b" in "bot")
        // "Zman" and "A Zulip user" match neither name nor email, so they
        // tie on relevance; the non-empty query then orders them by name
        // length, shorter first.
        "[email protected]", // Zman (4)
        "[email protected]", // A Zulip user (12)
    ]);

    // Test match by email (To get coverage for ok_users and ok_bots)
    assert.deepEqual(get_typeahead_result("[email protected]", ""), [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]);

    // Typeahead for direct message [query, "", ""]
    assert.deepEqual(get_typeahead_result("a", "", ""), [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]);

    const subscriber_email_1 = "[email protected]";
    const subscriber_email_2 = "[email protected]";
    const subscriber_email_3 = "[email protected]";
    peer_data.add_subscriber(1, b_user_2.user_id);
    peer_data.add_subscriber(1, b_user_3.user_id);
    peer_data.add_subscriber(1, b_bot.user_id);

    // For splitting based on recency
    recent_senders.process_stream_message({
        sender_id: 7,
        stream_id: 1,
        topic: "Dev topic",
        id: (next_id += 1),
    });
    recent_senders.process_stream_message({
        sender_id: 5,
        stream_id: 1,
        topic: "Dev topic",
        id: (next_id += 1),
    });
    recent_senders.process_stream_message({
        sender_id: 6,
        stream_id: 1,
        topic: "Dev topic",
        id: (next_id += 1),
    });

    // Typeahead for stream message [query, stream-id, topic-name]
    assert.deepEqual(get_typeahead_result("b", dev_sub.stream_id, "Dev topic"), [
        subscriber_email_2,
        subscriber_email_1,
        "[email protected]",
        subscriber_email_3,
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]);

    recent_senders.process_stream_message({
        sender_id: 5,
        stream_id: 2,
        topic: "Linux topic",
        id: (next_id += 1),
    });
    recent_senders.process_stream_message({
        sender_id: 7,
        stream_id: 2,
        topic: "Linux topic",
        id: (next_id += 1),
    });

    // No match
    assert.deepEqual(get_typeahead_result("h", linux_sub.stream_id, "Linux topic"), [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]);
});

test("sort_recipients all mention", () => {
    compose_state.set_message_type("stream");
    const all_obj = ct.broadcast_mentions()[0];
    assert.equal(all_obj.email, "all");
    assert.equal(all_obj.idx, 0);

    // Test person email is "all" or "everyone"
    const user_and_mention_items = [
        ...matches.map((user) => user_item(user)),
        broadcast_item(all_obj),
    ];
    const results = th.sort_recipients({
        users: user_and_mention_items,
        query: "a",
        current_stream_id: linux_sub.stream_id,
        current_topic: "Linux topic",
    });

    assertSameEmails(results, [
        broadcast_item(all_obj),
        a_user_item,
        a_bot_item,
        b_user_1_item,
        b_user_2_item,
        b_user_3_item,
        zman_item,
        b_bot_item,
    ]);
});

test("sort_recipients recent dms", () => {
    // A more recent direct message ranks the user higher.
    pm_conversations.recent.insert([b_user_2.user_id], 200);
    pm_conversations.recent.insert([b_user_1.user_id], 100);

    assert.deepEqual(get_typeahead_result("b"), [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        // Neither of these matches "b" or has DM history; with a non-empty
        // query the DM comparator prefers the shorter name, so "Zman" sorts
        // before "A Zulip user".
        "[email protected]",
        "[email protected]",
    ]);

    // Now prioritize stream membership over recent direct messages.
    peer_data.add_subscriber(linux_sub.stream_id, b_user_3.user_id);

    assert.deepEqual(get_typeahead_result("b", linux_sub.stream_id, "Linux topic"), [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ]);

    // get some line coverage
    assert.equal(
        th.compare_people_for_relevance(
            b_user_1_item,
            b_user_3_item,
            linux_sub.stream_id,
            "Linux topic",
        ),
        1,
    );
    assert.equal(
        th.compare_people_for_relevance(
            b_user_3_item,
            b_user_1_item,
            linux_sub.stream_id,
            "Linux topic",
        ),
        -1,
    );
});

test("sort_recipients dup bots", () => {
    const dup_objects = [...matches, a_bot];
    const user_items = dup_objects.map((user) => user_item(user));
    const recipients = th.sort_recipients({
        users: user_items,
        query: "b",
        current_stream_id: undefined,
        current_topic: "",
    });
    const recipients_email = recipients.map((person) => person.user.email);
    const expected = [
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
        "[email protected]",
    ];
    assert.deepEqual(recipients_email, expected);
});

test("sort_recipients dup alls", () => {
    compose_state.set_message_type("stream");
    const all_obj_item = broadcast_item(ct.broadcast_mentions()[0]);

    // full_name starts with same character but emails are 'all'
    const user_and_mention_items = [all_obj_item, a_user_item, all_obj_item];
    const recipients = th.sort_recipients({
        users: user_and_mention_items,
        query: "a",
        current_stream_id: linux_sub.stream_id,
        current_topic: "Linux topic",
    });

    const expected = [all_obj_item, a_user_item];
    assertSameEmails(recipients, expected);
});

test("sort_recipients dup alls direct message", () => {
    compose_state.set_message_type("private");
    const all_obj_item = broadcast_item(ct.broadcast_mentions()[0]);

    // full_name starts with same character but emails are 'all'
    const user_and_mention_items = [all_obj_item, a_user_item, all_obj_item];
    const recipients = th.sort_recipients({
        users: user_and_mention_items,
        query: "a",
    });

    const expected = [all_obj_item, a_user_item];
    assertSameEmails(recipients, expected);
});

test("sort_recipients subscribers", () => {
    // b_user_2 is a subscriber and b_user_1 is not.
    peer_data.add_subscriber(dev_sub.stream_id, b_user_2.user_id);
    const user_items = [b_user_2_item, b_user_1_item];
    const recipients = th.sort_recipients({
        users: user_items,
        query: "b",
        current_stream_id: dev_sub.stream_id,
        current_topic: "Dev topic",
    });
    const recipients_email = recipients.map((person) => person.user.email);
    const expected = ["[email protected]", "[email protected]"];
    assert.deepEqual(recipients_email, expected);
});

test("sort_recipients recent senders", () => {
    // b_user_2 is the only recent sender, b_user_3 is the only recent direct
    // message recipient, and all are subscribed to the stream Linux.
    peer_data.add_subscriber(linux_sub.stream_id, b_user_1.user_id);
    peer_data.add_subscriber(linux_sub.stream_id, b_user_2.user_id);
    peer_data.add_subscriber(linux_sub.stream_id, b_user_3.user_id);
    recent_senders.process_stream_message({
        sender_id: b_user_2.user_id,
        stream_id: linux_sub.stream_id,
        topic: "Linux topic",
        id: (next_id += 1),
    });
    pm_conversations.recent.insert([b_user_3.user_id], 100);
    const user_items = [b_user_1_item, b_user_2_item, b_user_3_item];
    const recipients = th.sort_recipients({
        users: user_items,
        query: "b",
        current_stream_id: linux_sub.stream_id,
        current_topic: "Linux topic",
    });
    const recipients_email = recipients.map((person) => person.user.email);
    // Prefer recent sender over recent direct message recipient.
    const expected = ["[email protected]", "[email protected]", "[email protected]"];
    assert.deepEqual(recipients_email, expected);
});

test("sort_recipients recent direct messages", () => {
    // b_user_3 has a recent direct message and b_user_2 does not, and
    // both are not subscribed to the stream Linux.
    pm_conversations.recent.insert([b_user_3.user_id], 100);
    const user_items = [b_user_3_item, b_user_2_item];
    const recipients = th.sort_recipients({
        users: user_items,
        query: "b",
        current_stream_id: linux_sub.stream_id,
        current_topic: "Linux topic",
    });
    const recipients_email = recipients.map((person) => person.user.email);
    const expected = ["[email protected]", "[email protected]"];
    assert.deepEqual(recipients_email, expected);
});

test("sort broadcast mentions for stream message type", () => {
    // test the normal case, which is that the
    // broadcast mentions are already sorted (we
    // actually had a bug where the sort would
    // randomly rearrange them)
    compose_state.set_message_type("stream");
    const mentions = ct.broadcast_mentions().toReversed();
    const broadcast_items = mentions.map((broadcast) => broadcast_item(broadcast));
    const results = th.sort_people_for_relevance(broadcast_items, dev_sub.stream_id, "Dev topic");

    assert.deepEqual(
        results.map((r) => r.user.email),
        ["all", "everyone", "stream", "channel", "topic"],
    );

    // Reverse the list to test actual sorting
    // and ensure test coverage for the defensive
    // code.  Also, add in some people users with
    // no stream/topic relevance, who should sort
    // after the wildcard mentions.
    const user_or_mention_items = [
        zman_item,
        ...ct
            .broadcast_mentions()
            .map((broadcast) => broadcast_item(broadcast))
            .toReversed(),
        a_user_item,
    ];
    const results2 = th.sort_people_for_relevance(
        user_or_mention_items,
        dev_sub.stream_id,
        "Dev topic",
    );

    assert.deepEqual(
        results2.map((r) => r.user.email),
        ["all", "everyone", "stream", "channel", "topic", a_user.email, zman.email],
    );
});

test("sort broadcast mentions for direct message type", () => {
    compose_state.set_message_type("private");
    const mentions = ct.broadcast_mentions().toReversed();
    const broadcast_items = mentions.map((broadcast) => broadcast_item(broadcast));
    const results = th.sort_people_for_relevance(broadcast_items);

    assert.deepEqual(
        results.map((r) => r.user.email),
        ["all", "everyone"],
    );

    // With no stream context and no direct message history for these
    // users, the wildcard mentions sort before them.
    const user_or_mention_items = [
        zman_item,
        ...ct
            .broadcast_mentions()
            .map((broadcast) => broadcast_item(broadcast))
            .toReversed(),
        a_user_item,
    ];
    const results2 = th.sort_people_for_relevance(user_or_mention_items);

    assert.deepEqual(
        results2.map((r) => r.user.email),
        ["all", "everyone", a_user.email, zman.email],
    );
});

test("test compare directly for broadcast vs user", () => {
    // This is important for ensuring test coverage.
    // We don't technically need it now, but our test
    // coverage is subject to the whims of how JS sorts.
    const all_obj = ct.broadcast_mentions()[0];
    const all_obj_item = broadcast_item(all_obj);

    assert.equal(th.compare_people_for_relevance(all_obj_item, all_obj_item), 0);
    // Without stream context, broadcasts come before users with no
    // direct message history.
    assert.equal(th.compare_people_for_relevance(all_obj_item, zman_item), -1);
    assert.equal(th.compare_people_for_relevance(zman_item, all_obj_item), 1);
});

test("render_person when emails hidden", ({mock_template, override}) => {
    // Test render_person with regular person, under hidden email visibility case
    override(realm, "custom_profile_field_types", {
        PRONOUNS: {id: 8, name: "Pronouns"},
    });
    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.primary, b_user_1.full_name);
        assert.equal(args.secondary, null);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_person(b_user_1_item), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person", ({mock_template, override}) => {
    // Test render_person with regular person
    a_user.delivery_email = "[email protected]";
    override(realm, "custom_profile_field_types", {
        PRONOUNS: {id: 8, name: "Pronouns"},
    });
    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.primary, a_user.full_name);
        assert.equal(args.secondary, a_user.delivery_email);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_person(a_user_item), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person special_item_text", ({mock_template}) => {
    // Test render_person with special_item_text person
    const special_person = {
        email: "[email protected]",
        full_name: "Special person",
        is_admin: false,
        is_bot: false,
        user_id: 7,
        special_item_text: "special_text",
    };

    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.primary, special_person.special_item_text);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_person(broadcast_item(special_person)), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_stream", ({mock_template}) => {
    // Test render_stream with short description
    let rendered = false;
    const stream = {
        description: "This is the description of the test stream.",
        rendered_description: "This is the description of the test stream.",
        stream_id: 42,
        name: "test stream",
    };

    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.stream, stream);
        assert.equal(args.secondary_html, stream.rendered_description);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_stream(stream), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_stream_topic", ({mock_template}) => {
    let rendered = false;
    const streamData = {
        invite_only: true,
        is_web_public: false,
        color: "blue",
        name: "Design",
        description: "Design related discussions.",
        rendered_description: "",
        subscribed: true,
    };

    const topic_object = {
        topic: "Test topic title",
        stream_data: {
            invite_only: true,
            is_web_public: false,
            color: "blue",
            name: "Design",
            description: "Design related discussions.",
            rendered_description: "",
            subscribed: true,
        },
        type: "topic_list",
        is_stream_only: false,
    };

    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.topic, "Test topic title");
        assert.equal(args.type, "topic_list");
        assert.equal(args.is_stream_only, false);
        assert.equal(args.is_stream_topic, true);
        assert.deepEqual(args.stream_data, streamData);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_stream_topic(topic_object), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_emoji", ({mock_template}) => {
    // Test render_emoji with normal emoji.
    let expected_template_data = {
        primary: "thumbs up",
        emoji_code: "1f44d",
        is_emoji: true,
        has_image: false,
        has_pronouns: false,
        has_secondary: false,
        has_secondary_html: false,
        has_status: false,
    };
    let rendered = false;
    let test_emoji = {
        emoji_name: "thumbs_up",
        emoji_code: "1f44d",
    };
    emoji.active_realm_emojis.clear();
    emoji.active_realm_emojis.set("realm_emoji", "TBD");

    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.deepEqual(args, expected_template_data);
        rendered = true;
        return "typeahead-item-stub";
    });
    assert.equal(th.render_emoji(test_emoji), "typeahead-item-stub");
    assert.ok(rendered);

    // Test render_emoji with normal emoji.
    rendered = false;
    expected_template_data = {
        primary: "realm emoji",
        img_src: "TBD",
        is_emoji: true,
        has_image: true,
        has_pronouns: false,
        has_secondary: false,
        has_secondary_html: false,
        has_status: false,
    };
    test_emoji = {
        emoji_name: "realm_emoji",
        emoji_url: "TBD",
    };

    assert.equal(th.render_emoji(test_emoji), "typeahead-item-stub");
    assert.ok(rendered);
});

test("sort_slash_commands", () => {
    const slash_commands = [
        {name: "my"},
        {name: "poll"},
        {name: "me"},
        {name: "mine"},
        {name: "test"},
        {name: "ping"},
    ];
    assert.deepEqual(th.sort_slash_commands(slash_commands, "m"), [
        {name: "me"},
        {name: "mine"},
        {name: "my"},
        {name: "ping"},
        {name: "poll"},
        {name: "test"},
    ]);
});

test("compare_language", () => {
    assert.ok(th.compare_language("javascript", "haskell") < 0);
    assert.ok(th.compare_language("haskell", "javascript") > 0);

    // "abap" and "amdgpu" both have priority = 0 at this time, so there is a tie.
    // Alphabetical order should be used to break that tie.
    assert.equal(th.compare_language("abap", "amdgpu"), util.strcmp("abap", "amdgpu"));

    // Test with languages that aren't in the generated pygments data.
    assert.equal(pygments_data.langs.custom_a, undefined);
    assert.equal(pygments_data.langs.custom_b, undefined);
    // Since custom_a has no popularity score, it gets sorted behind python.
    assert.equal(th.compare_language("custom_a", "python"), 1);
    assert.equal(th.compare_language("python", "custom_a"), -1);
    // Whenever there is a tie, even in the case neither have a popularity
    // score, then alphabetical order is used to break the tie.
    assert.equal(th.compare_language("custom_a", "custom_b"), util.strcmp("custom_a", "custom_b"));
});

test("compare_users_for_dms", () => {
    // Same user should return 0
    assert.equal(th.compare_users_for_dms(a_user, a_user), 0);

    // Alphabetical fallback when neither user has direct message history
    assert.equal(
        th.compare_users_for_dms(a_user, b_user_1),
        util.strcmp(a_user.full_name, b_user_1.full_name),
    );

    // Reverse order should match strcmp behavior
    assert.equal(
        th.compare_users_for_dms(b_user_1, a_user),
        util.strcmp(b_user_1.full_name, a_user.full_name),
    );

    // A more recent direct message conversation takes priority.
    pm_conversations.recent.insert([a_user.user_id], 200);
    pm_conversations.recent.insert([b_user_1.user_id], 100);

    assert.equal(th.compare_users_for_dms(a_user, b_user_1), -1);
    assert.equal(th.compare_users_for_dms(b_user_1, a_user), 1);

    // Any direct message history ranks above none.
    pm_conversations.clear_for_testing();
    pm_conversations.recent.insert([b_user_1.user_id], 100);

    assert.equal(th.compare_users_for_dms(a_user, b_user_1), 1);
    assert.equal(th.compare_users_for_dms(b_user_1, a_user), -1);

    // Equally recent direct messages fall back to alphabetical order.
    pm_conversations.clear_for_testing();
    pm_conversations.recent.insert([a_user.user_id, b_user_1.user_id], 100);

    assert.equal(
        th.compare_users_for_dms(a_user, b_user_1),
        util.strcmp(a_user.full_name, b_user_1.full_name),
    );
});

test("sort_group_setting_options", ({override_rewire}) => {
    function get_group_setting_typeahead_result(query, target_group) {
        const users = people.get_realm_active_human_users().map((user) => ({type: "user", user}));
        const groups = user_groups.get_all_realm_user_groups().map((group) => ({
            type: "user_group",
            ...group,
        }));
        const result = th.sort_group_setting_options({
            users,
            query,
            groups,
            target_group,
        });
        return result.map((item) => {
            if (item.type === "user") {
                return item.user.full_name;
            }

            return item.name;
        });
    }

    assert.deepEqual(get_group_setting_typeahead_result("Bo", second_bob_group), [
        bob_system_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
        everyone_group.name,
        members_group.name,
        admins_group.name,
        a_user.full_name,
        zman.full_name,
    ]);

    assert.deepEqual(get_group_setting_typeahead_result("bo", second_bob_group), [
        bob_system_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
        everyone_group.name,
        members_group.name,
        admins_group.name,
        a_user.full_name,
        zman.full_name,
    ]);

    assert.deepEqual(get_group_setting_typeahead_result("Z", second_bob_group), [
        zman.full_name,
        admins_group.name,
        a_user.full_name,
        bob_system_group.name,
        everyone_group.name,
        members_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
    ]);

    assert.deepEqual(get_group_setting_typeahead_result("me", second_bob_group), [
        members_group.name,
        bob_system_group.name,
        everyone_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
        zman.full_name,
    ]);

    assert.deepEqual(get_group_setting_typeahead_result("ever", second_bob_group), [
        everyone_group.name,
        members_group.name,
        bob_system_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
        zman.full_name,
    ]);

    assert.deepEqual(get_group_setting_typeahead_result("translated: members", second_bob_group), [
        members_group.name,
        bob_system_group.name,
        everyone_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
        zman.full_name,
    ]);

    override_rewire(bootstrap_typeahead, "MAX_ITEMS", 6);
    assert.deepEqual(get_group_setting_typeahead_result("Bo", second_bob_group), [
        bob_system_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_2.full_name,
        b_user_1.full_name,
        b_user_3.full_name,
    ]);
});

test("compare_group_setting_options", () => {
    // User group has higher priority than user.
    assert.equal(th.compare_group_setting_options(a_user_item, bob_group_item, bob_group), 1);
    assert.equal(th.compare_group_setting_options(bob_group_item, a_user_item, bob_group), -1);

    // System user group has higher priority than other user groups.
    assert.equal(
        th.compare_group_setting_options(bob_group_item, bob_system_group_item, bob_group),
        1,
    );
    assert.equal(
        th.compare_group_setting_options(bob_system_group_item, bob_group_item, bob_group),
        -1,
    );
    assert.equal(
        th.compare_group_setting_options(admins_group_item, bob_system_group_item, bob_group),
        1,
    );

    // In case both groups are not system groups, alphabetical order is used to decide priority.
    assert.equal(th.compare_group_setting_options(bob_group_item, admins_group_item, bob_group), 1);
    assert.equal(
        th.compare_group_setting_options(admins_group_item, bob_group_item, bob_group),
        -1,
    );

    // A user always has a higher priority than a bot.
    assert.equal(th.compare_group_setting_options(b_bot_item, b_user_1_item, bob_group), 1);
    assert.equal(th.compare_group_setting_options(b_user_1_item, b_bot_item, bob_group), -1);

    // A user who is a member of the group being changed has higher priority.
    // If both the users are not members of the group being changed, alphabetical order
    // is used to decide priority.
    assert.equal(th.compare_group_setting_options(b_user_1_item, b_user_2_item, bob_group), -1);
    assert.equal(
        th.compare_group_setting_options(b_user_1_item, b_user_2_item, second_bob_group),
        1,
    );

    // Get coverage for case where two users have same names. Original order is preserved
    // in such cases.
    assert.equal(th.compare_group_setting_options(b_user_1_item, b_user_1_item, bob_group), 0);
});

test("sort_stream_or_group_members_options", ({override_rewire}) => {
    function get_stream_or_group_members_typeahead_result(query) {
        const users = people.get_realm_active_human_users().map((user) => ({type: "user", user}));
        const groups = user_groups.get_all_realm_user_groups().map((group) => ({
            type: "user_group",
            ...group,
        }));
        const result = th.sort_stream_or_group_members_options({
            users,
            query,
            groups,
            for_stream_subscribers: true,
        });
        return result.map((item) => {
            if (item.type === "user") {
                return item.user.full_name;
            }

            return item.name;
        });
    }

    assert.deepEqual(get_stream_or_group_members_typeahead_result("Bo"), [
        bob_group.name,
        second_bob_group.name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        bob_system_group.name,
        members_group.name,
        admins_group.name,
        a_user.full_name,
        zman.full_name,
        everyone_group.name,
    ]);

    assert.deepEqual(get_stream_or_group_members_typeahead_result("bo"), [
        bob_group.name,
        second_bob_group.name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        bob_system_group.name,
        members_group.name,
        admins_group.name,
        a_user.full_name,
        zman.full_name,
        everyone_group.name,
    ]);

    assert.deepEqual(get_stream_or_group_members_typeahead_result("Z"), [
        zman.full_name,
        admins_group.name,
        a_user.full_name,
        members_group.name,
        bob_group.name,
        second_bob_group.name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        bob_system_group.name,
        everyone_group.name,
    ]);

    assert.deepEqual(get_stream_or_group_members_typeahead_result("me"), [
        members_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        zman.full_name,
        bob_system_group.name,
        everyone_group.name,
    ]);

    assert.deepEqual(get_stream_or_group_members_typeahead_result("ever"), [
        members_group.name,
        everyone_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        zman.full_name,
        bob_system_group.name,
    ]);

    assert.deepEqual(get_stream_or_group_members_typeahead_result("translated: members"), [
        members_group.name,
        admins_group.name,
        bob_group.name,
        second_bob_group.name,
        a_user.full_name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        zman.full_name,
        bob_system_group.name,
        everyone_group.name,
    ]);

    override_rewire(bootstrap_typeahead, "MAX_ITEMS", 6);
    assert.deepEqual(get_stream_or_group_members_typeahead_result("Bo"), [
        bob_group.name,
        second_bob_group.name,
        b_user_1.full_name,
        b_user_2.full_name,
        b_user_3.full_name,
        bob_system_group.name,
    ]);
});

test("compare_stream_or_group_members_options", () => {
    // Non system user group has higher priority than user for both streams and groups UI.
    assert.equal(
        th.compare_stream_or_group_members_options(a_user_item, bob_group_item, undefined, true),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(a_user_item, bob_group_item, undefined, false),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(bob_group_item, a_user_item, undefined, true),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(bob_group_item, a_user_item, undefined, false),
        -1,
    );
    // User has higher priority than non `role:members` system user group for streams UI.
    assert.equal(
        th.compare_stream_or_group_members_options(
            a_user_item,
            bob_system_group_item,
            undefined,
            true,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_system_group_item,
            a_user_item,
            undefined,
            true,
        ),
        1,
    );
    // System user group has lower priority than other user groups for both streams and groups UI.
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            bob_system_group_item,
            undefined,
            true,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            bob_system_group_item,
            undefined,
            false,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_system_group_item,
            bob_group_item,
            undefined,
            true,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_system_group_item,
            bob_group_item,
            undefined,
            false,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            bob_system_group_item,
            undefined,
            true,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            bob_system_group_item,
            undefined,
            false,
        ),
        -1,
    );

    // Members group always takes priority against any other group for stream subscribers UI.
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            members_group_item,
            undefined,
            true,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            members_group_item,
            bob_group_item,
            undefined,
            true,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            members_group_item,
            undefined,
            true,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            members_group_item,
            admins_group_item,
            undefined,
            true,
        ),
        -1,
    );
    // For group members UI, members group does not take priority.
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            members_group_item,
            undefined,
            false,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            members_group_item,
            bob_group_item,
            undefined,
            false,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            members_group_item,
            undefined,
            false,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            members_group_item,
            admins_group_item,
            undefined,
            false,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            a_user_item,
            members_group_item,
            undefined,
            false,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            members_group_item,
            a_user_item,
            undefined,
            false,
        ),
        1,
    );

    // In case both groups are not system groups, alphabetical order is used to decide priority.
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            admins_group_item,
            undefined,
            true,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            bob_group_item,
            admins_group_item,
            undefined,
            false,
        ),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            bob_group_item,
            undefined,
            true,
        ),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(
            admins_group_item,
            bob_group_item,
            undefined,
            false,
        ),
        -1,
    );

    // Use alphabetical order to compare two users.
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_1_item, b_user_2_item, undefined, true),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_1_item, b_user_2_item, undefined, false),
        -1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_2_item, b_user_1_item, undefined, true),
        1,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_2_item, b_user_1_item, undefined, false),
        1,
    );

    // Get coverage for case where two users have same names. Original order is preserved
    // in such cases.
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_1_item, b_user_1_item, undefined, true),
        0,
    );
    assert.equal(
        th.compare_stream_or_group_members_options(b_user_1_item, b_user_1_item, undefined, false),
        0,
    );
});

test("render_person shows value of custom profile fields in secondary", ({
    mock_template,
    override,
}) => {
    a_user.profile_data ??= {};

    override(realm, "custom_profile_field_types", {
        SHORT_TEXT: {id: 1, name: "Short text"},
        PRONOUNS: {id: 3, name: "Pronouns"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 1,
            name: "Alpha field",
            type: realm.custom_profile_field_types.SHORT_TEXT.id,
            use_for_user_matching: true,
        },
    ]);

    people.set_custom_profile_field_data(a_user.user_id, {
        id: 1,
        value: "Alpha",
    });

    let rendered = false;

    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.secondary, "Alpha");
        rendered = true;
        return "typeahead-item-stub";
    });

    assert.equal(th.render_person(a_user_item, {query: "Alpha"}), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person shows both email and custom profile fields as secondary if both matches", ({
    mock_template,
    override,
}) => {
    override(realm, "custom_profile_field_types", {
        SHORT_TEXT: {id: 1, name: "Short text"},
        PRONOUNS: {id: 3, name: "Pronouns"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 1,
            name: "Alpha field",
            type: realm.custom_profile_field_types.SHORT_TEXT.id,
            use_for_user_matching: true,
        },
    ]);

    people.set_custom_profile_field_data(a_user.user_id, {
        id: 1,
        value: "a_user",
    });

    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.secondary, "[email protected], a_user");
        rendered = true;
        return "typeahead-item-stub";
    });

    assert.equal(th.render_person(a_user_item, {query: "a_user"}), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person shows the email and custom profile field a diacritic query matched", ({
    mock_template,
    override,
}) => {
    // "a_usèr" matches this user's email and field once diacritics are
    // stripped, so the secondary line has to show both rather than hide them.
    override(realm, "custom_profile_field_types", {
        SHORT_TEXT: {id: 1, name: "Short text"},
        PRONOUNS: {id: 3, name: "Pronouns"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 1,
            name: "Alpha field",
            type: realm.custom_profile_field_types.SHORT_TEXT.id,
            use_for_user_matching: true,
        },
    ]);

    people.set_custom_profile_field_data(a_user.user_id, {
        id: 1,
        value: "a_user",
    });

    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.equal(args.secondary, "[email protected], a_user");
        rendered = true;
        return "typeahead-item-stub";
    });

    assert.equal(th.render_person(a_user_item, {query: "a_usèr"}), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person skips custom profile fields not used for user matching", ({
    mock_template,
    override,
}) => {
    a_user.profile_data ??= {};

    override(realm, "custom_profile_field_types", {
        PRONOUNS: {id: 3, name: "Pronouns"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 1,
            name: "Alpha field",
            type: realm.custom_profile_field_types.PRONOUNS.id,
        },
    ]);

    people.set_custom_profile_field_data(a_user.user_id, {
        id: 1,
        value: "Alpha",
    });

    let rendered = false;

    mock_template("typeahead_list_item.hbs", false, (args) => {
        assert.notEqual(args.secondary, "Alpha");
        rendered = true;
        return "typeahead-item-stub";
    });

    assert.equal(th.render_person(a_user_item, {query: "Alpha"}), "typeahead-item-stub");
    assert.ok(rendered);
});

test("render_person with matching custom profile field but email hidden", ({
    mock_template,
    override,
}) => {
    override(realm, "custom_profile_field_types", {
        SHORT_TEXT: {id: 1, name: "Short text"},
        PRONOUNS: {id: 3, name: "Pronouns"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 1,
            name: "Alpha field",
            type: realm.custom_profile_field_types.SHORT_TEXT.id,
            use_for_user_matching: true,
        },
    ]);

    b_user_1.delivery_email = null;

    people.set_custom_profile_field_data(b_user_1.user_id, {
        id: 1,
        value: "Alpha",
    });

    let rendered = false;
    mock_template("typeahead_list_item.hbs", false, (args) => {
        // When email is null and custom field matches,
        // secondary should only show the custom field value, not "null, value"
        assert.equal(args.secondary, "Alpha");
        rendered = true;
        return "typeahead-item-stub";
    });

    assert.equal(th.render_person(b_user_1_item, {query: ""}), "typeahead-item-stub");
    assert.ok(rendered);
});

test("query_matches_person_name strips diacritics from both query and name", () => {
    // query_matches_person_name now always strips diacritics from both sides,
    // so a diacritic query matches an ASCII name and an ASCII query matches a
    // name with diacritics.
    const adam_diacritic = make_user({
        email: "[email protected]",
        full_name: "Ądam",
        user_id: 101,
    });
    const adam_ascii = make_user({
        email: "[email protected]",
        full_name: "adam",
        user_id: 102,
    });

    assert.equal(th.query_matches_person_name("ądam", user_item(adam_diacritic)), true);
    assert.equal(th.query_matches_person_name("ądam", user_item(adam_ascii)), true);
    assert.equal(th.query_matches_person_name("adam", user_item(adam_diacritic)), true);
    assert.equal(th.query_matches_person_name("zoe", user_item(adam_ascii)), false);
});

test("query_matches_group_name strips diacritics from both query and name", () => {
    // Like query_matches_person_name, group-name filtering is
    // diacritics-agnostic: a diacritic query matches an ASCII group name
    // and an ASCII query matches a group name with diacritics.
    const diacritic_group = make_user_group({
        id: 200,
        name: "Ągents",
        description: "",
        members: new Set([b_user_2.user_id]),
        is_system_group: false,
    });
    const ascii_group = make_user_group({
        id: 201,
        name: "agents",
        description: "",
        members: new Set([b_user_2.user_id]),
        is_system_group: false,
    });
    user_groups.add(diacritic_group);
    user_groups.add(ascii_group);

    assert.equal(th.query_matches_group_name("ągents", user_group_item(diacritic_group)), true);
    assert.equal(th.query_matches_group_name("ągents", user_group_item(ascii_group)), true);
    assert.equal(th.query_matches_group_name("agents", user_group_item(diacritic_group)), true);
    assert.equal(th.query_matches_group_name("zoe", user_group_item(ascii_group)), false);
});

test("query_matches_person matches custom profile fields when they are enabled for user matching ", ({
    override,
}) => {
    a_user.profile_data ??= {};

    override(realm, "custom_profile_field_types", {
        SHORT_TEXT: {id: 1, name: "Short text"},
        EXTERNAL_ACCOUNT: {id: 2, name: "External account"},
    });

    override(realm, "custom_profile_fields", [
        {
            id: 51,
            name: "Alpha field",
            type: realm.custom_profile_field_types.SHORT_TEXT.id,
            use_for_user_matching: true,
        },
        {
            id: 52,
            name: "Beta field",
            type: realm.custom_profile_field_types.EXTERNAL_ACCOUNT.id,
        },
    ]);

    people.set_custom_profile_field_data(a_user.user_id, {
        id: 51,
        value: "Alpha",
    });
    people.set_custom_profile_field_data(a_user.user_id, {
        id: 52,
        value: "Beta",
    });

    assert.equal(th.query_matches_person("alpha", a_user_item, undefined, true), true);
    assert.equal(th.query_matches_person("beta", a_user_item, undefined, true), false);
});

test("sort_recipients prioritizes exact diacritic matches", () => {
    const aaron_item = {
        type: "user",
        user: {full_name: "aaron", email: "[email protected]", is_bot: false},
    };

    const aaron_diacritic_item = {
        type: "user",
        user: {full_name: "Ąaron", email: "[email protected]", is_bot: false},
    };

    const users = [aaron_item, aaron_diacritic_item];

    const result = th.sort_recipients({
        users,
        query: "ą",
        groups: [],
        max_num_items: 10,
    });

    assert.deepEqual(result, [aaron_diacritic_item, aaron_item]);
});

test("sort_recipients: diacritic query allows diacritic-stripped ASCII fallback", () => {
    const adam_item = {
        type: "user",
        user: {full_name: "adam", email: "[email protected]", is_bot: false},
    };
    const zoe_item = {
        type: "user",
        user: {full_name: "zoe", email: "[email protected]", is_bot: false},
    };

    const result = th.sort_recipients({
        users: [adam_item, zoe_item],
        query: "ą",
        groups: [],
        max_num_items: 10,
    });

    assert.deepEqual(result, [adam_item, zoe_item]);
});

test("sort_recipients: plain ASCII query ranks diacritic names below matches", () => {
    const adam_item = {
        type: "user",
        user: {full_name: "adam", email: "[email protected]", is_bot: false},
    };
    const adam_diacritic_item = {
        type: "user",
        user: {full_name: "Ądam", email: "[email protected]", is_bot: false},
    };

    const result = th.sort_recipients({
        users: [adam_item, adam_diacritic_item],
        query: "a",
        groups: [],
        max_num_items: 10,
    });

    assert.deepEqual(result, [adam_item, adam_diacritic_item]);
});

test("sort_recipients: diacritic query matches via word boundary (diacritic-stripped)", () => {
    const john_adam_item = {
        type: "user",
        user: {full_name: "John adam", email: "[email protected]", is_bot: false},
    };
    const zoe_item = {
        type: "user",
        user: {full_name: "zoe", email: "[email protected]", is_bot: false},
    };

    const result = th.sort_recipients({
        users: [john_adam_item, zoe_item],
        query: "ą",
        groups: [],
        max_num_items: 10,
    });

    assert.deepEqual(result, [john_adam_item, zoe_item]);
});

test("sort_recipients surfaces groups whose names match a diacritic query", () => {
    // Regression test: a group whose display name begins with a
    // diacritic query lands in the diacritic-prefix bucket, which
    // sort_recipients must still surface rather than drop.
    const diacritic_group = make_user_group({
        id: 100,
        name: "Ągents",
        description: "",
        members: new Set([b_user_2.user_id]),
        is_system_group: false,
    });
    user_groups.add(diacritic_group);

    const result = th.sort_recipients({
        users: [],
        query: "ą",
        groups: [user_group_item(diacritic_group)],
        max_num_items: 10,
    });

    assert.equal(result.length, 1);
    assert.equal(result[0].id, diacritic_group.id);
});