Zulip server and web application. Open-source team chat that helps teams stay productive and focused.
"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);
});