Field value
", }; people.set_custom_profile_field_data(person.user_id, field); assert.equal(person.profile_data[field.id].value, "Field value"); assert.equal(person.profile_data[field.id].rendered_value, "Field value
"); }); test_people("is_current_user_only_owner", () => { const person = people.get_by_email(me.email); person.is_owner = false; page_params.is_owner = false; assert.ok(!people.is_current_user_only_owner()); person.is_owner = true; page_params.is_owner = true; assert.ok(people.is_current_user_only_owner()); people.add_active_user(realm_owner); assert.ok(!people.is_current_user_only_owner()); }); test_people("recipient_counts", () => { const user_id = 99; assert.equal(people.get_recipient_count({user_id}), 0); people.incr_recipient_count(user_id); people.incr_recipient_count(user_id); assert.equal(people.get_recipient_count({user_id}), 2); assert.equal(people.get_recipient_count({pm_recipient_count: 5}), 5); }); test_people("filtered_users", () => { people.add_active_user(charles); people.add_active_user(maria); people.add_active_user(ashton); people.add_active_user(linus); people.add_active_user(noah); people.add_active_user(plain_noah); const search_term = "a"; const users = people.get_realm_users(); let filtered_people = people.filter_people_by_search_terms(users, [search_term]); assert.equal(filtered_people.size, 2); assert.ok(filtered_people.has(ashton.user_id)); assert.ok(filtered_people.has(maria.user_id)); assert.ok(!filtered_people.has(charles.user_id)); filtered_people = people.filter_people_by_search_terms(users, []); assert.equal(filtered_people.size, 0); filtered_people = people.filter_people_by_search_terms(users, ["ltorv"]); assert.equal(filtered_people.size, 1); assert.ok(filtered_people.has(linus.user_id)); filtered_people = people.filter_people_by_search_terms(users, ["ch di", "maria"]); assert.equal(filtered_people.size, 2); assert.ok(filtered_people.has(charles.user_id)); assert.ok(filtered_people.has(maria.user_id)); // Test filtering of names with diacritics // This should match Nöôáàh by ignoring diacritics, and also match Nooaah filtered_people = people.filter_people_by_search_terms(users, ["noOa"]); assert.equal(filtered_people.size, 2); assert.ok(filtered_people.has(noah.user_id)); assert.ok(filtered_people.has(plain_noah.user_id)); // This should match ëmerson, but not emerson filtered_people = people.filter_people_by_search_terms(users, ["ëm"]); assert.equal(filtered_people.size, 1); assert.ok(filtered_people.has(noah.user_id)); // Test filtering with undefined user users.push(invalid_user); filtered_people = people.filter_people_by_search_terms(users, ["ltorv"]); assert.equal(filtered_people.size, 1); assert.ok(filtered_people.has(linus.user_id)); }); test_people("multi_user_methods", () => { people.add_active_user(emp401); people.add_active_user(emp402); // The order of user_ids is relevant here. assert.equal(emp401.user_id, 401); assert.equal(emp402.user_id, 402); let emails_string = people.user_ids_string_to_emails_string("402,401"); assert.equal(emails_string, "emp401@example.com,emp402@example.com"); emails_string = people.slug_to_emails("402,401"); assert.equal(emails_string, "emp401@example.com,emp402@example.com"); emails_string = people.slug_to_emails("402,401-group"); assert.equal(emails_string, "emp401@example.com,emp402@example.com"); emails_string = "emp402@example.com,EMP401@EXAMPLE.COM"; let user_ids_string = people.emails_strings_to_user_ids_string(emails_string); assert.equal(user_ids_string, "401,402"); user_ids_string = people.reply_to_to_user_ids_string(emails_string); assert.equal(user_ids_string, "401,402"); const slug = people.emails_to_slug(emails_string); assert.equal(slug, "401,402-group"); assert.equal(people.reply_to_to_user_ids_string("invalid@example.com"), undefined); }); test_people("emails_to_full_names_string", () => { people.add_active_user(charles); people.add_active_user(maria); assert.equal( people.emails_to_full_names_string([charles.email, maria.email]), `${charles.full_name}, ${maria.full_name}`, ); assert.equal( people.emails_to_full_names_string([ charles.email, "unknown-email@example.com", maria.email, ]), `${charles.full_name}, translated: Unknown user, ${maria.full_name}`, ); }); test_people("concat_huddle", () => { /* We assume that user_ids passed in to concat_huddle have already been validated, so we don't need actual people for these tests to pass. That may change in the future. */ const user_ids = [303, 301, 302]; assert.equal(people.concat_huddle(user_ids, 304), "301,302,303,304"); // IMPORTANT: we always want to sort // ids numerically to create huddle strings. assert.equal(people.concat_huddle(user_ids, 99), "99,301,302,303"); }); test_people("message_methods", () => { people.add_active_user(charles); people.add_active_user(maria); people.add_active_user(ashton); // We don't rely on Maria to have all flags set explicitly-- // undefined values are just treated as falsy. assert.equal(maria.is_guest, undefined); assert.equal( people.small_avatar_url_for_person(maria), "https://secure.gravatar.com/avatar/6dbdd7946b58d8b11351fcb27e5cdd55?d=identicon&s=50", ); assert.equal( people.medium_avatar_url_for_person(maria), "https://secure.gravatar.com/avatar/6dbdd7946b58d8b11351fcb27e5cdd55?d=identicon&s=500", ); assert.equal(people.medium_avatar_url_for_person(charles), "/avatar/301/medium?version=0"); assert.equal(people.medium_avatar_url_for_person(ashton), "/avatar/303/medium?version=0"); muted_users.add_muted_user(30); assert.deepEqual(people.sender_info_for_recent_view_row([30]), [ { avatar_url_small: "http://zulip.zulipdev.com/avatar/30?s=50", is_muted: true, email: "me@example.com", full_name: me.full_name, is_admin: false, is_bot: false, is_guest: false, is_moderator: false, role: 400, timezone: "America/Los_Angeles", user_id: 30, }, ]); let message = { type: "private", display_recipient: [{id: maria.user_id}, {id: me.user_id}, {id: charles.user_id}], sender_id: charles.user_id, }; assert.equal(people.pm_with_url(message), "#narrow/dm/301,302-group"); assert.equal(people.pm_perma_link(message), "#narrow/dm/30,301,302-group"); assert.equal(people.pm_reply_to(message), "Athens@example.com,charles@example.com"); assert.equal(people.small_avatar_url(message), "http://charles.com/foo.png?s=50"); message = { type: "private", display_recipient: [{id: maria.user_id}, {id: me.user_id}], avatar_url: "legacy.png", }; assert.equal(people.pm_with_url(message), "#narrow/dm/302-Maria-Athens"); assert.equal(people.pm_perma_link(message), "#narrow/dm/30,302-dm"); assert.equal(people.pm_reply_to(message), "Athens@example.com"); assert.equal(people.small_avatar_url(message), "http://zulip.zulipdev.com/legacy.png?s=50"); message = { avatar_url: undefined, sender_id: maria.user_id, }; assert.equal( people.small_avatar_url(message), "https://secure.gravatar.com/avatar/6dbdd7946b58d8b11351fcb27e5cdd55?d=identicon&s=50", ); blueslip.expect("error", "Unknown user_id in maybe_get_user_by_id"); message = { avatar_url: undefined, sender_email: "foo@example.com", sender_id: 9999999, }; assert.equal( people.small_avatar_url(message), "https://secure.gravatar.com/avatar/b48def645758b95537d4424c84d1a9ff?d=identicon&s=50", ); message = { sender_id: ashton.user_id, }; assert.equal( people.small_avatar_url(message), `http://zulip.zulipdev.com/avatar/${ashton.user_id}?s=50`, ); message = { type: "private", display_recipient: [{id: me.user_id}], }; assert.equal(people.pm_with_url(message), "#narrow/dm/30-Me-Myself"); assert.equal(people.pm_perma_link(message), "#narrow/dm/30-dm"); message = {type: "stream"}; assert.equal(people.pm_with_user_ids(message), undefined); assert.equal(people.all_user_ids_in_pm(message), undefined); // Test undefined user_ids assert.equal(people.pm_reply_to(message), undefined); assert.equal(people.pm_reply_user_string(message), undefined); assert.equal(people.pm_with_url(message), undefined); // Test sender_is_bot const bot = bot_botson; people.add_active_user(bot); message = {sender_id: bot.user_id}; assert.equal(people.sender_is_bot(message), true); message = {sender_id: maria.user_id}; assert.equal(people.sender_is_bot(message), undefined); message = {sender_id: undefined}; assert.equal(people.sender_is_bot(message), false); // Test sender_is_guest people.add_active_user(guest); message = {sender_id: guest.user_id}; assert.equal(people.sender_is_guest(message), true); message = {sender_id: maria.user_id}; assert.equal(people.sender_is_guest(message), undefined); message = {sender_id: charles.user_id}; assert.equal(people.sender_is_guest(message), false); message = {sender_id: undefined}; assert.equal(people.sender_is_guest(message), false); }); test_people("extract_people_from_message", () => { let message = { type: "stream", sender_full_name: maria.full_name, sender_id: maria.user_id, sender_email: maria.email, }; assert.ok(!people.is_known_user_id(maria.user_id)); blueslip.expect("error", "Added user late"); people.extract_people_from_message(message); assert.ok(people.is_known_user_id(maria.user_id)); blueslip.reset(); // Get line coverage message = { type: "private", display_recipient: [invalid_user], }; people.extract_people_from_message(message); }); test_people("maybe_incr_recipient_count", () => { const maria_recip = { id: maria.user_id, }; people.add_active_user(maria); let message = { type: "private", display_recipient: [maria_recip], sent_by_me: true, }; assert.equal(people.get_recipient_count(maria), 0); people.maybe_incr_recipient_count(message); assert.equal(people.get_recipient_count(maria), 1); // Test all the no-op conditions to get test // coverage. message = { type: "private", sent_by_me: false, display_recipient: [maria_recip], }; people.maybe_incr_recipient_count(message); assert.equal(people.get_recipient_count(maria), 1); const other_invalid_recip = { email: "invalid2@example.com", id: 500, unknown_local_echo_user: true, }; message = { type: "private", sent_by_me: true, display_recipient: [other_invalid_recip], }; people.maybe_incr_recipient_count(message); assert.equal(people.get_recipient_count(maria), 1); message = { type: "stream", }; people.maybe_incr_recipient_count(message); assert.equal(people.get_recipient_count(maria), 1); }); test_people("slugs", () => { people.add_active_user(debbie); const slug = people.emails_to_slug(debbie.email); assert.equal(slug, "501-Debra-Henton"); const email = people.slug_to_emails(slug); assert.equal(email, "debbie71@example.com"); // Test undefined slug assert.equal(people.emails_to_slug("does@not.exist"), undefined); }); test_people("get_people_for_search_bar", ({override}) => { let user_ids; override(message_user_ids, "user_ids", () => user_ids); for (const i of _.range(20)) { const person = { email: "whatever@email.com", full_name: "James Jones", user_id: 1000 + i, }; people.add_active_user(person); } user_ids = []; const big_results = people.get_people_for_search_bar("James"); assert.equal(big_results.length, 20); user_ids = [1001, 1002, 1003, 1004, 1005, 1006]; const small_results = people.get_people_for_search_bar("Jones"); // As long as there are 5+ results among the user_ids // in message_user_ids, we will get a small result and not // search all people. assert.equal(small_results.length, 6); }); test_people("updates", () => { const old_email = "FOO@example.com"; const new_email = "bar@example.com"; const user_id = 502; let person = { email: old_email, user_id, full_name: "Foo Barson", }; people.add_active_user(person); // Do sanity checks on our data. assert.equal(people.get_by_email(old_email).user_id, user_id); assert.ok(!people.is_cross_realm_email(old_email)); assert.equal(people.get_by_email(new_email), undefined); // DO THE EMAIL UPDATE HERE. people.update_email(user_id, new_email); // Now look up using the new email. assert.equal(people.get_by_email(new_email).user_id, user_id); assert.ok(!people.is_cross_realm_email(new_email)); const all_people = get_all_persons(); assert.equal(all_people.length, 3); person = all_people.find((p) => p.email === new_email); assert.equal(person.full_name, "Foo Barson"); // Test shim where we can still retrieve user info using the // old email. blueslip.expect( "warn", "Obsolete email passed to get_by_email: FOO@example.com new email = bar@example.com", ); person = people.get_by_email(old_email); assert.equal(person.user_id, user_id); }); test_people("update_email_in_reply_to", () => { people.add_active_user(charles); people.add_active_user(maria); let reply_to = " charles@example.com, athens@example.com"; assert.equal(people.update_email_in_reply_to(reply_to, 9999, "whatever"), reply_to); assert.equal( people.update_email_in_reply_to(reply_to, maria.user_id, "maria@example.com"), "charles@example.com,maria@example.com", ); reply_to = " charles@example.com, athens@example.com, invalid@example.com"; assert.equal(people.update_email_in_reply_to(reply_to, 9999, "whatever"), reply_to); }); test_people("track_duplicate_full_names", () => { people.add_active_user(maria); people.add_active_user(stephen1); assert.ok(!people.is_duplicate_full_name("Stephen King")); assert.equal(people.get_user_id_from_name("Stephen King"), stephen1.user_id); // Now duplicate the Stephen King name. people.add_active_user({...stephen2}); // For duplicate names we won't try to guess which // user_id the person means; the UI should use // other codepaths for disambiguation. assert.equal(people.get_user_id_from_name("Stephen King"), undefined); assert.ok(people.is_duplicate_full_name("Stephen King")); assert.ok(!people.is_duplicate_full_name("Maria Athens")); assert.ok(!people.is_duplicate_full_name("Some Random Name")); // It is somewhat janky that we have to clone // stephen2 here. It would be nice if people.set_full_name // just took a user_id as the first parameter. people.set_full_name({...stephen2}, "Stephen King JP"); assert.ok(!people.is_duplicate_full_name("Stephen King")); assert.ok(!people.is_duplicate_full_name("Stephen King JP")); }); test_people("get_mention_syntax", () => { people.add_active_user(stephen1); people.add_active_user(stephen2); people.add_active_user(maria); assert.ok(people.is_duplicate_full_name("Stephen King")); blueslip.expect("warn", "get_mention_syntax called without user_id."); assert.equal(people.get_mention_syntax("Stephen King"), "@**Stephen King**"); blueslip.reset(); assert.equal(people.get_mention_syntax("Stephen King", 601), "@**Stephen King|601**"); assert.equal(people.get_mention_syntax("Stephen King", 602), "@**Stephen King|602**"); assert.equal(people.get_mention_syntax("Maria Athens", 603), "@**Maria Athens**"); // Following tests handle a special case when `full_name` matches with a wildcard. // // At this point, there is no duplicate full name, `all`, so we should still get // mention syntax with `user_id` appended to it. people.add_active_user(all1); assert.equal(people.get_mention_syntax("all", 1202), "@**all|1202**"); people.add_active_user(all2); assert.equal(people.get_mention_syntax("all", 1203), "@**all|1203**"); }); test_people("initialize", () => { people.init(); const params = {}; params.realm_non_active_users = [ { email: "retiree@example.com", user_id: 15, full_name: "Retiree", }, ]; params.realm_users = [ { email: "alice@example.com", user_id: 16, full_name: "Alice", }, ]; params.cross_realm_bots = [ { email: "bot@example.com", user_id: 17, full_name: "Test Bot", }, ]; const my_user_id = 42; people.initialize(my_user_id, params); assert.equal(people.is_active_user_for_popover(17), true); assert.ok(people.is_cross_realm_email("bot@example.com")); assert.ok(people.is_valid_email_for_compose("bot@example.com")); assert.ok(people.is_valid_email_for_compose("alice@example.com")); assert.ok(people.is_valid_email_for_compose("retiree@example.com")); assert.ok(!people.is_valid_email_for_compose("totally-bogus-username@example.com")); assert.ok(people.is_valid_bulk_emails_for_compose(["bot@example.com", "alice@example.com"])); assert.ok(!people.is_valid_bulk_emails_for_compose(["not@valid.com", "alice@example.com"])); assert.ok(people.is_my_user_id(42)); const fetched_retiree = people.get_by_user_id(15); assert.equal(fetched_retiree.full_name, "Retiree"); assert.equal(page_params.realm_users, undefined); assert.equal(page_params.cross_realm_bots, undefined); assert.equal(page_params.realm_non_active_users, undefined); }); test_people("filter_for_user_settings_search", () => { /* This function calls matches_user_settings_search, so that is where we do more thorough testing. This test is just a sanity check for now. */ page_params.is_admin = false; const fred_smith = {full_name: "Fred Smith"}; const alice_lee = {full_name: "Alice Lee"}; const jenny_franklin = {full_name: "Jenny Franklin"}; const persons = [fred_smith, alice_lee, jenny_franklin]; assert.deepEqual(people.filter_for_user_settings_search(persons, "fr"), [ fred_smith, jenny_franklin, ]); assert.deepEqual(people.filter_for_user_settings_search(persons, "le"), [alice_lee]); }); test_people("matches_user_settings_search", () => { const match = people.matches_user_settings_search; page_params.is_admin = false; assert.equal(match({email: "fred@example.com"}, "fred"), false); assert.equal(match({full_name: "Fred Smith"}, "fr"), true); page_params.is_admin = true; assert.equal(match({delivery_email: "fred@example.com"}, "fr"), true); assert.equal( match( { delivery_email: "bogus", email: "fred@example.com", }, "fr", ), false, ); assert.equal(match({delivery_email: "fred@example.com"}, "fr"), true); assert.equal(match({email: "fred@example.com"}, "fr"), false); // test normal stuff assert.equal(match({email: "fred@example.com"}, "st"), false); assert.equal(match({full_name: "Fred Smith"}, "st"), false); assert.equal(match({full_name: "Joe Frederick"}, "st"), false); assert.equal(match({delivery_email: "fred@example.com"}, "fr"), true); assert.equal(match({full_name: "Fred Smith"}, "fr"), true); assert.equal(match({full_name: "Joe Frederick"}, "fr"), true); // test in-string matches...we may want not to be so liberal // here about matching, as it's noisy for large realms (who // need search the most) assert.equal(match({delivery_email: "fred@example.com"}, "re"), true); assert.equal(match({full_name: "Fred Smith"}, "re"), true); assert.equal(match({full_name: "Joe Frederick"}, "re"), true); }); test_people("is_valid_full_name_and_user_id", () => { assert.ok(!people.is_valid_full_name_and_user_id("bogus", 99)); assert.ok(!people.is_valid_full_name_and_user_id(me.full_name, 99)); assert.ok(people.is_valid_full_name_and_user_id(me.full_name, me.user_id)); }); test_people("emails_strings_to_user_ids_array", () => { people.add_active_user(steven); people.add_active_user(maria); let user_ids = people.emails_strings_to_user_ids_array(`${steven.email},${maria.email}`); assert.deepEqual(user_ids, [steven.user_id, maria.user_id]); blueslip.expect("warn", "Unknown emails"); user_ids = people.emails_strings_to_user_ids_array("dummyuser@example.com"); assert.equal(user_ids, undefined); }); test_people("get_visible_email", () => { people.add_active_user(steven); people.add_active_user(maria); let email = people.get_visible_email(steven); assert.equal(email, steven.delivery_email); email = people.get_visible_email(maria); assert.equal(email, maria.email); }); test_people("get_active_message_people", () => { message_user_ids.user_ids = () => [steven.user_id, maria.user_id, alice1.user_id]; people.add_active_user(steven); people.add_active_user(maria); people.add_active_user(alice1); let active_message_people = people.get_active_message_people(); assert.deepEqual(active_message_people, [steven, maria, alice1]); people.deactivate(alice1); active_message_people = people.get_active_message_people(); assert.deepEqual(active_message_people, [steven, maria]); }); test_people("huddle_string", () => { assert.equal(people.huddle_string({type: "stream"}), undefined); function huddle(user_ids) { return people.huddle_string({ type: "private", display_recipient: user_ids.map((id) => ({id})), }); } people.add_active_user(maria); people.add_active_user(bob); assert.equal(huddle([]), undefined); assert.equal(huddle([me.user_id, maria.user_id]), undefined); assert.equal(huddle([me.user_id, maria.user_id, bob.user_id]), "203,302"); }); test_people("get_realm_active_human_users", () => { let humans = people.get_realm_active_human_users(); assert.equal(humans.length, 1); assert.deepEqual(humans, [me]); people.add_active_user(maria); people.add_active_user(bot_botson); humans = people.get_realm_active_human_users(); assert.equal(humans.length, 2); assert.deepEqual(humans, [me, maria]); people.deactivate(maria); humans = people.get_realm_active_human_users(); assert.equal(humans.length, 1); assert.deepEqual(humans, [me]); }); test_people("should_show_guest_user_indicator", () => { people.add_active_user(charles); people.add_active_user(guest); page_params.realm_enable_guest_user_indicator = false; assert.equal(people.should_add_guest_user_indicator(charles.user_id), false); assert.equal(people.should_add_guest_user_indicator(guest.user_id), false); page_params.realm_enable_guest_user_indicator = true; assert.equal(people.should_add_guest_user_indicator(charles.user_id), false); assert.equal(people.should_add_guest_user_indicator(guest.user_id), true); }); test_people("get_user_by_id_assert_valid", ({override}) => { people.add_active_user(charles); const inaccessible_user_id = 99; page_params.realm_bot_domain = "zulipdev.com"; override(settings_data, "user_can_access_all_other_users", () => false); let user = people.get_user_by_id_assert_valid(inaccessible_user_id); assert.equal(user.full_name, "translated: Unknown user"); assert.equal(user.user_id, inaccessible_user_id); assert.ok(user.is_inaccessible_user); assert.equal(user.email, "user99@zulipdev.com"); user = people.get_user_by_id_assert_valid(charles.user_id); assert.equal(user.full_name, charles.full_name); assert.ok(!user.is_inaccessible_user); assert.equal(user.email, charles.email); override(settings_data, "user_can_access_all_other_users", () => true); assert.throws( () => { people.get_user_by_id_assert_valid(199); }, { name: "Error", message: "Unknown user_id in get_by_user_id: 199", }, ); user = people.get_user_by_id_assert_valid(charles.user_id); assert.equal(user.full_name, charles.full_name); assert.ok(!user.is_inaccessible_user); assert.equal(user.email, charles.email); }); // reset to native Date() run_test("reset MockDate", () => { MockDate.reset(); });